// @generated by scripts/build-runtime.mjs; do not edit.
// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
import {
  effectiveSyncSetupRemoteIdentity,
  localConfigPath,
  syncSetupStorageReview,
  updateLocalConfig,
  validateConfigName
} from "./chunk-APZVBSM6.ts";
import {
  normalizeSyncInclude
} from "./chunk-YQ6UW7IF.ts";

// src/settings-management.ts
var SyncSetupReviewChangedError = class extends Error {
  constructor(message) {
    super(message);
    this.name = "SyncSetupReviewChangedError";
  }
};
async function saveNewV3Settings(input, signal) {
  validateConfigName(input.setupName, "sync setup");
  validateConfigName(input.connectionName, "storage connection");
  const settings = {
    version: 3,
    activeSyncSetup: input.setupName,
    onSwitch: "ask-before-pull",
    storageConnections: { [input.connectionName]: structuredClone(input.connection) },
    syncSetups: {
      [input.setupName]: {
        ...structuredClone(input.setup),
        storage: { ...input.setup.storage, connection: input.connectionName }
      }
    }
  };
  await updateLocalConfig((current) => {
    if (Object.keys(current.storageConnections).length || Object.keys(current.syncSetups).length) {
      throw new Error(`Settings already exist: ${localConfigPath()}`);
    }
    return settings;
  }, signal);
  return settings;
}
async function addStorageConnection(name, connection, signal) {
  validateConfigName(name, "storage connection");
  await updateSettings((settings) => {
    if (Object.hasOwn(settings.storageConnections, name)) {
      throw new Error(`Storage connection already exists: ${name}`);
    }
    return {
      ...settings,
      storageConnections: {
        ...settings.storageConnections,
        [name]: structuredClone(connection)
      }
    };
  }, signal);
}
async function updateStorageConnection(name, update, expectedSetups, signal) {
  validateConfigName(name, "storage connection");
  await updateSettings((settings) => {
    const connection = settings.storageConnections[name];
    if (!connection) throw new Error(`Storage connection not found: ${name}`);
    const currentSetups = referencingSetupNames(settings.syncSetups, name);
    if (expectedSetups && !sameNames(currentSetups, expectedSetups)) {
      throw new Error(
        `Storage connection \u201C${name}\u201D usage changed while it was open; reopen it and review the affected sync setups.`
      );
    }
    const nextConnection = update(structuredClone(connection));
    const nextConnections = { ...settings.storageConnections, [name]: nextConnection };
    assertUniqueLocations(settings.syncSetups, nextConnections);
    return { ...settings, storageConnections: nextConnections };
  }, signal);
}
async function addSyncSetup(name, setup, signal) {
  validateConfigName(name, "sync setup");
  await updateSettings((settings) => {
    if (Object.hasOwn(settings.syncSetups, name))
      throw new Error(`Sync setup already exists: ${name}`);
    if (!Object.hasOwn(settings.storageConnections, setup.storage.connection)) {
      throw new Error(`Storage connection not found: ${setup.storage.connection}`);
    }
    const nextSetups = { ...settings.syncSetups, [name]: structuredClone(setup) };
    assertUniqueLocations(nextSetups, settings.storageConnections);
    return {
      ...settings,
      syncSetups: nextSetups,
      ...settings.activeSyncSetup ? {} : { activeSyncSetup: name }
    };
  }, signal);
}
async function updateSyncSetup(name, update, options = {}) {
  validateConfigName(name, "sync setup");
  await updateSettings((settings) => {
    const setup = settings.syncSetups[name];
    if (!setup) throw new Error(`Sync setup not found: ${name}`);
    if (options.expectedInclude && !sameNames(normalizeSyncInclude(setup.sync.include), options.expectedInclude)) {
      throw new SyncSetupReviewChangedError(
        `Sync setup \u201C${name}\u201D included content changed while it was open; reopen it and review the current selection.`
      );
    }
    if (options.expectedStorage) {
      const connectionName = setup.storage.connection;
      const connection = settings.storageConnections[connectionName];
      if (!connection || !sameStorageReview(
        syncSetupStorageReview(name, setup, connectionName, connection),
        options.expectedStorage
      )) {
        throw new SyncSetupReviewChangedError(
          `Sync setup \u201C${name}\u201D storage changed while it was open; reopen it and review the current storage location.`
        );
      }
    }
    const nextSetup = update(structuredClone(setup));
    if (!Object.hasOwn(settings.storageConnections, nextSetup.storage.connection)) {
      throw new Error(`Storage connection not found: ${nextSetup.storage.connection}`);
    }
    const nextSetups = { ...settings.syncSetups, [name]: nextSetup };
    assertUniqueLocations(nextSetups, settings.storageConnections);
    return { ...settings, syncSetups: nextSetups };
  }, options.signal);
}
async function removeSyncSetup(name, signal) {
  validateConfigName(name, "sync setup");
  await updateSettings((settings) => {
    if (!Object.hasOwn(settings.syncSetups, name)) throw new Error(`Sync setup not found: ${name}`);
    const isCurrent = settings.activeSyncSetup === name;
    if (isCurrent && Object.keys(settings.syncSetups).length > 1) {
      throw new Error("Switch to another sync setup before removing the current setup.");
    }
    const syncSetups = { ...settings.syncSetups };
    delete syncSetups[name];
    const next = { ...settings, syncSetups };
    if (isCurrent) delete next.activeSyncSetup;
    return next;
  }, signal);
}
async function removeStorageConnection(name, signal) {
  validateConfigName(name, "storage connection");
  await updateSettings((settings) => {
    const referenced = referencingSetupNames(settings.syncSetups, name)[0];
    if (referenced) {
      throw new Error(`Storage connection \u201C${name}\u201D is used by sync setup \u201C${referenced}\u201D.`);
    }
    if (!Object.hasOwn(settings.storageConnections, name)) {
      throw new Error(`Storage connection not found: ${name}`);
    }
    const storageConnections = { ...settings.storageConnections };
    delete storageConnections[name];
    return { ...settings, storageConnections };
  }, signal);
}
async function updateSettings(update, signal) {
  return updateLocalConfig((settings) => {
    if (settings.version !== 3) {
      throw new Error("Storage connections and sync setups require version 3 pi-sync settings.");
    }
    return update(settings);
  }, signal);
}
function referencingSetupNames(setups, connection) {
  return Object.entries(setups).filter(([, setup]) => setup.storage.connection === connection).map(([name]) => name).sort((left, right) => left.localeCompare(right));
}
function assertUniqueLocations(setups, connections) {
  const identities = /* @__PURE__ */ new Map();
  for (const [name, setup] of Object.entries(setups)) {
    const connection = connections[setup.storage.connection];
    if (!connection) throw new Error(`Storage connection not found: ${setup.storage.connection}`);
    const identity = effectiveSyncSetupRemoteIdentity(setup, connection);
    const previous = identities.get(identity);
    if (previous) {
      throw new Error(`Sync setup \u201C${name}\u201D duplicates the storage location of \u201C${previous}\u201D.`);
    }
    identities.set(identity, name);
  }
}
function sameNames(left, right) {
  return left.length === right.length && left.every((name, index) => name === right[index]);
}
function sameStorageReview(left, right) {
  return left.connectionName === right.connectionName && left.storageKind === right.storageKind && left.storagePath === right.storagePath && left.bucket === right.bucket && left.branch === right.branch;
}

export {
  SyncSetupReviewChangedError,
  saveNewV3Settings,
  addStorageConnection,
  updateStorageConnection,
  addSyncSetup,
  updateSyncSetup,
  removeSyncSetup,
  removeStorageConnection
};
//# sourceMappingURL=chunk-4F3W4CSC.ts.map