atom.io 0.11.0 → 0.12.1

package/data/dist/index.cjs

@@ -0,0 +1,614 @@
+'use strict';
+
+var internal = require('atom.io/internal');
+var atom_io = require('atom.io');
+var setRtx = require('atom.io/transceivers/set-rtx');
+
+// src/dict.ts
+function dict(findState, index, store = internal.IMPLICIT.STORE) {
+  return internal.createSelector(
+    {
+      key: `${findState.key}Dict`,
+      get: ({ get }) => {
+        const keys = get(index);
+        return keys.reduce((acc, key) => {
+          acc[key] = get(findState(key));
+          return acc;
+        }, {});
+      }
+    },
+    void 0,
+    store
+  );
+}
+
+// ../../rel8/junction/src/junction.ts
+var Junction = class {
+  constructor(data, config) {
+    this.relations = /* @__PURE__ */ new Map();
+    this.contents = /* @__PURE__ */ new Map();
+    this.makeContentKey = (a, b) => `${a}:${b}`;
+    var _a, _b, _c, _d;
+    this.a = data.between[0];
+    this.b = data.between[1];
+    this.cardinality = data.cardinality;
+    if (!(config == null ? void 0 : config.externalStore)) {
+      this.relations = new Map((_a = data.relations) == null ? void 0 : _a.map(([a, b]) => [a, new Set(b)]));
+      this.contents = new Map(data.contents);
+    }
+    this.isContent = (_b = config == null ? void 0 : config.isContent) != null ? _b : null;
+    if (config == null ? void 0 : config.makeContentKey) {
+      this.makeContentKey = config.makeContentKey;
+    }
+    if (config == null ? void 0 : config.externalStore) {
+      const externalStore = config.externalStore;
+      this.has = (a, b) => externalStore.has(a, b);
+      this.addRelation = (a, b) => {
+        externalStore.addRelation(a, b);
+      };
+      this.deleteRelation = (a, b) => {
+        externalStore.deleteRelation(a, b);
+      };
+      this.replaceRelationsSafely = (a, bs) => {
+        externalStore.replaceRelationsSafely(a, bs);
+      };
+      this.replaceRelationsUnsafely = (a, bs) => {
+        externalStore.replaceRelationsUnsafely(a, bs);
+      };
+      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key);
+      if (externalStore.getContent) {
+        this.getContentInternal = (contentKey) => {
+          return externalStore.getContent(contentKey);
+        };
+        this.setContent = (contentKey, content) => {
+          externalStore.setContent(contentKey, content);
+        };
+        this.deleteContent = (contentKey) => {
+          externalStore.deleteContent(contentKey);
+        };
+      }
+      for (const [x, ys] of (_c = data.relations) != null ? _c : []) {
+        for (const y of ys)
+          this.addRelation(x, y);
+      }
+      for (const [contentKey, content] of (_d = data.contents) != null ? _d : []) {
+        this.setContent(contentKey, content);
+      }
+    }
+  }
+  getRelatedKeys(key) {
+    return this.relations.get(key);
+  }
+  addRelation(a, b) {
+    let aRelations = this.relations.get(a);
+    let bRelations = this.relations.get(b);
+    if (aRelations) {
+      aRelations.add(b);
+    } else {
+      aRelations = /* @__PURE__ */ new Set([b]);
+      this.relations.set(a, aRelations);
+    }
+    if (bRelations) {
+      bRelations.add(a);
+    } else {
+      bRelations = /* @__PURE__ */ new Set([a]);
+      this.relations.set(b, bRelations);
+    }
+  }
+  deleteRelation(a, b) {
+    const aRelations = this.relations.get(a);
+    if (aRelations) {
+      aRelations.delete(b);
+      if (aRelations.size === 0) {
+        this.relations.delete(a);
+      }
+      const bRelations = this.relations.get(b);
+      if (bRelations) {
+        bRelations.delete(a);
+        if (bRelations.size === 0) {
+          this.relations.delete(b);
+        }
+      }
+    }
+  }
+  replaceRelationsUnsafely(a, bs) {
+    this.relations.set(a, new Set(bs));
+    for (const b of bs) {
+      const bRelations = /* @__PURE__ */ new Set([a]);
+      this.relations.set(b, bRelations);
+    }
+  }
+  replaceRelationsSafely(a, bs) {
+    const aRelationsPrev = this.relations.get(a);
+    if (aRelationsPrev) {
+      for (const b of aRelationsPrev) {
+        const bRelations = this.relations.get(b);
+        if (bRelations) {
+          if (bRelations.size === 1) {
+            this.relations.delete(b);
+          } else {
+            bRelations.delete(a);
+          }
+          this.contents.delete(this.makeContentKey(a, b));
+        }
+      }
+    }
+    this.relations.set(a, new Set(bs));
+    for (const b of bs) {
+      let bRelations = this.relations.get(b);
+      if (bRelations) {
+        bRelations.add(a);
+      } else {
+        bRelations = /* @__PURE__ */ new Set([a]);
+        this.relations.set(b, bRelations);
+      }
+    }
+  }
+  getContentInternal(contentKey) {
+    return this.contents.get(contentKey);
+  }
+  setContent(contentKey, content) {
+    this.contents.set(contentKey, content);
+  }
+  deleteContent(contentKey) {
+    this.contents.delete(contentKey);
+  }
+  toJSON() {
+    return {
+      between: [this.a, this.b],
+      cardinality: this.cardinality,
+      relations: [...this.relations.entries()].map(([a, b]) => [a, [...b]]),
+      contents: [...this.contents.entries()]
+    };
+  }
+  set(a, ...rest) {
+    var _a;
+    const b = typeof rest[0] === `string` ? rest[0] : a[this.b];
+    const content = ((_a = rest[1]) != null ? _a : typeof rest[0] === `string`) ? void 0 : rest[0];
+    a = typeof a === `string` ? a : a[this.a];
+    switch (this.cardinality) {
+      case `1:1`: {
+        const bPrev = this.getRelatedKey(a);
+        if (bPrev && bPrev !== b)
+          this.delete(bPrev, a);
+      }
+      case `1:n`: {
+        const aPrev = this.getRelatedKey(b);
+        if (aPrev && aPrev !== a)
+          this.delete(aPrev, b);
+      }
+    }
+    if (content) {
+      const contentKey = this.makeContentKey(a, b);
+      this.setContent(contentKey, content);
+    }
+    this.addRelation(a, b);
+    return this;
+  }
+  delete(x, b) {
+    b = typeof b === `string` ? b : x[this.b];
+    const a = typeof x === `string` ? x : x[this.a];
+    if (a === void 0 && typeof b === `string`) {
+      const bRelations = this.getRelatedKeys(b);
+      if (bRelations) {
+        for (const a2 of bRelations) {
+          this.delete(a2, b);
+        }
+      }
+    }
+    if (typeof a === `string` && b === void 0) {
+      const aRelations = this.getRelatedKeys(a);
+      if (aRelations) {
+        for (const b2 of aRelations) {
+          this.delete(a, b2);
+        }
+      }
+    }
+    if (typeof a === `string` && typeof b === `string`) {
+      this.deleteRelation(a, b);
+      const contentKey = this.makeContentKey(a, b);
+      this.deleteContent(contentKey);
+    }
+    return this;
+  }
+  getRelatedKey(key) {
+    const relations = this.getRelatedKeys(key);
+    if (relations) {
+      if (relations.size > 1) {
+        console.warn(
+          `${relations.size} related keys were found for key "${key}": (${[
+            ...relations
+          ].map((k) => `"${k}"`).join(`, `)}). Only one related key was expected.`
+        );
+      }
+      for (const relation of relations) {
+        return relation;
+      }
+    }
+  }
+  replaceRelations(a, relations, config) {
+    const hasContent = !Array.isArray(relations);
+    const bs = hasContent ? Object.keys(relations) : relations;
+    if (config == null ? void 0 : config.reckless) {
+      this.replaceRelationsUnsafely(a, bs);
+    } else {
+      this.replaceRelationsSafely(a, bs);
+    }
+    if (hasContent) {
+      for (const b of bs) {
+        const contentKey = this.makeContentKey(a, b);
+        const content = relations[b];
+        this.setContent(contentKey, content);
+      }
+    }
+    return this;
+  }
+  getContent(a, b) {
+    const contentKey = this.makeContentKey(a, b);
+    return this.getContentInternal(contentKey);
+  }
+  getRelationEntries(input) {
+    const a = input[this.a];
+    const b = input[this.b];
+    if (a !== void 0 && b === void 0) {
+      const aRelations = this.getRelatedKeys(a);
+      if (aRelations) {
+        return [...aRelations].map((b2) => {
+          var _a;
+          return [b2, (_a = this.getContent(a, b2)) != null ? _a : null];
+        });
+      }
+    }
+    if (a === void 0 && b !== void 0) {
+      const bRelations = this.getRelatedKeys(b);
+      if (bRelations) {
+        return [...bRelations].map((a2) => {
+          var _a;
+          return [a2, (_a = this.getContent(a2, b)) != null ? _a : null];
+        });
+      }
+    }
+    return [];
+  }
+  has(a, b) {
+    var _a;
+    if (b) {
+      const setA = this.getRelatedKeys(a);
+      return (_a = setA == null ? void 0 : setA.has(b)) != null ? _a : false;
+    }
+    return this.relations.has(a);
+  }
+};
+
+// src/join.ts
+var TRANSACTORS = { get: atom_io.getState, set: atom_io.setState };
+function capitalize(string) {
+  return string[0].toUpperCase() + string.slice(1);
+}
+function join(options, defaultContent, store = internal.IMPLICIT.STORE) {
+  const a = options.between[0];
+  const b = options.between[1];
+  const findRelatedKeysState = internal.createMutableAtomFamily(
+    {
+      key: `${options.key}/relatedKeys`,
+      default: () => new setRtx.SetRTX(),
+      mutable: true,
+      fromJson: (json) => new setRtx.SetRTX(json),
+      toJson: (set) => [...set]
+    },
+    store
+  );
+  const getRelatedKeys = ({ get }, key) => get(findRelatedKeysState(key));
+  const addRelation = (transactors, a2, b2) => {
+    const aKeys = getRelatedKeys(transactors, a2);
+    const bKeys = getRelatedKeys(transactors, b2);
+    if (aKeys) {
+      transactors.set(findRelatedKeysState(a2), aKeys.add(b2));
+    } else {
+      transactors.set(findRelatedKeysState(a2), new setRtx.SetRTX([b2]));
+    }
+    if (bKeys) {
+      transactors.set(findRelatedKeysState(b2), bKeys.add(a2));
+    } else {
+      transactors.set(findRelatedKeysState(b2), new setRtx.SetRTX([a2]));
+    }
+  };
+  const deleteRelation = (transactors, a2, b2) => {
+    const aKeys = getRelatedKeys(transactors, a2);
+    if (aKeys) {
+      aKeys.delete(b2);
+      if (aKeys.size === 0) {
+        transactors.set(findRelatedKeysState(a2), void 0);
+      }
+      const bKeys = getRelatedKeys(transactors, b2);
+      if (bKeys) {
+        bKeys.delete(a2);
+        if (bKeys.size === 0) {
+          transactors.set(findRelatedKeysState(b2), void 0);
+        }
+      }
+    }
+  };
+  const replaceRelationsSafely = (transactors, a2, bs) => {
+    const aKeys = getRelatedKeys(transactors, a2);
+    if (aKeys) {
+      for (const b2 of aKeys) {
+        const bKeys = getRelatedKeys(transactors, b2);
+        if (bKeys) {
+          bKeys.delete(a2);
+          if (bKeys.size === 0) {
+            transactors.set(findRelatedKeysState(b2), void 0);
+          }
+        }
+      }
+    }
+    transactors.set(findRelatedKeysState(a2), new setRtx.SetRTX(bs));
+    for (const b2 of bs) {
+      const bKeys = getRelatedKeys(transactors, b2);
+      if (bKeys) {
+        bKeys.add(a2);
+      } else {
+        transactors.set(findRelatedKeysState(b2), new setRtx.SetRTX([a2]));
+      }
+    }
+  };
+  const replaceRelationsUnsafely = (transactors, a2, bs) => {
+    transactors.set(findRelatedKeysState(a2), new setRtx.SetRTX(bs));
+    for (const b2 of bs) {
+      let bKeys = getRelatedKeys(transactors, b2);
+      if (bKeys) {
+        bKeys.add(a2);
+      } else {
+        bKeys = new setRtx.SetRTX([a2]);
+        transactors.set(findRelatedKeysState(b2), bKeys);
+      }
+    }
+  };
+  const has = (transactors, a2, b2) => {
+    var _a, _b;
+    const aKeys = getRelatedKeys(transactors, a2);
+    return b2 ? (_a = aKeys == null ? void 0 : aKeys.has(b2)) != null ? _a : false : ((_b = aKeys == null ? void 0 : aKeys.size) != null ? _b : 0) > 0;
+  };
+  const baseExternalStoreConfiguration = {
+    getRelatedKeys: (key) => getRelatedKeys(TRANSACTORS, key),
+    addRelation: (a2, b2) => addRelation(TRANSACTORS, a2, b2),
+    deleteRelation: (a2, b2) => deleteRelation(TRANSACTORS, a2, b2),
+    replaceRelationsSafely: (a2, bs) => replaceRelationsSafely(TRANSACTORS, a2, bs),
+    replaceRelationsUnsafely: (a2, bs) => replaceRelationsUnsafely(TRANSACTORS, a2, bs),
+    has: (a2, b2) => has(TRANSACTORS, a2, b2)
+  };
+  let externalStore;
+  let findContentState;
+  if (defaultContent) {
+    findContentState = internal.createAtomFamily(
+      {
+        key: `${options.key}/content`,
+        default: defaultContent
+      },
+      store
+    );
+    const getContent = ({ get }, key) => get(findContentState(key));
+    const setContent = (transactors, key, content) => transactors.set(findContentState(key), content);
+    const deleteContent = (transactors, key) => transactors.set(findContentState(key), void 0);
+    const externalStoreWithContentConfiguration = {
+      getContent: (contentKey) => {
+        const content = getContent(TRANSACTORS, contentKey);
+        return content;
+      },
+      setContent: (contentKey, content) => {
+        setContent(TRANSACTORS, contentKey, content);
+      },
+      deleteContent: (contentKey) => {
+        deleteContent(TRANSACTORS, contentKey);
+      }
+    };
+    externalStore = Object.assign(
+      baseExternalStoreConfiguration,
+      externalStoreWithContentConfiguration
+    );
+  } else {
+    externalStore = baseExternalStoreConfiguration;
+  }
+  const relations = new Junction(options, {
+    externalStore,
+    makeContentKey: (...args) => args.sort().join(`:`)
+  });
+  const createSingleKeyStateFamily = () => internal.createSelectorFamily(
+    {
+      key: `${options.key}/singleRelatedKey`,
+      get: (key) => ({ get }) => {
+        const relatedKeys = get(findRelatedKeysState(key));
+        for (const relatedKey of relatedKeys) {
+          return relatedKey;
+        }
+      }
+    },
+    store
+  );
+  const getMultipleKeyStateFamily = () => internal.getJsonFamily(findRelatedKeysState, store);
+  const createSingleEntryStateFamily = () => internal.createSelectorFamily(
+    {
+      key: `${options.key}/singleRelatedEntry`,
+      get: (key) => ({ get }) => {
+        const relatedKeys = get(findRelatedKeysState(key));
+        for (const relatedKey of relatedKeys) {
+          const contentKey = relations.makeContentKey(key, relatedKey);
+          return [relatedKey, get(findContentState(contentKey))];
+        }
+      }
+    },
+    store
+  );
+  const getMultipleEntryStateFamily = () => internal.createSelectorFamily(
+    {
+      key: `${options.key}/multipleRelatedEntries`,
+      get: (key) => ({ get }) => {
+        const relatedKeys = get(findRelatedKeysState(key));
+        return [...relatedKeys].map((relatedKey) => {
+          const contentKey = relations.makeContentKey(key, relatedKey);
+          return [relatedKey, get(findContentState(contentKey))];
+        });
+      }
+    },
+    store
+  );
+  switch (options.cardinality) {
+    case `1:1`: {
+      const findSingleRelatedKeyState = createSingleKeyStateFamily();
+      const stateKeyA = `${a}KeyOf${capitalize(b)}`;
+      const stateKeyB = `${b}KeyOf${capitalize(a)}`;
+      const findStateBase = {
+        [stateKeyA]: findSingleRelatedKeyState,
+        [stateKeyB]: findSingleRelatedKeyState
+      };
+      let findState;
+      if (defaultContent) {
+        const findSingleRelatedEntryState = createSingleEntryStateFamily();
+        const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
+        const entriesStateKeyB = `${b}EntryOf${capitalize(a)}`;
+        const findStateWithContent = {
+          [entriesStateKeyA]: findSingleRelatedEntryState,
+          [entriesStateKeyB]: findSingleRelatedEntryState
+        };
+        findState = Object.assign(findStateBase, findStateWithContent);
+      } else {
+        findState = findStateBase;
+      }
+      return {
+        relations,
+        findState
+      };
+    }
+    case `1:n`: {
+      const findSingleRelatedKeyState = createSingleKeyStateFamily();
+      const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
+      const stateKeyA = `${a}KeyOf${capitalize(b)}`;
+      const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+      const findStateBase = {
+        [stateKeyA]: findSingleRelatedKeyState,
+        [stateKeyB]: findMultipleRelatedKeysState
+      };
+      let findState;
+      if (defaultContent) {
+        const findSingleRelatedEntryState = createSingleEntryStateFamily();
+        const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
+        const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
+        const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+        const findStateWithContent = {
+          [entriesStateKeyA]: findSingleRelatedEntryState,
+          [entriesStateKeyB]: findMultipleRelatedEntriesState
+        };
+        findState = Object.assign(findStateBase, findStateWithContent);
+      } else {
+        findState = findStateBase;
+      }
+      return {
+        relations,
+        findState
+      };
+    }
+    case `n:n`: {
+      const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
+      const stateKeyA = `${a}KeysOf${capitalize(b)}`;
+      const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+      const findStateBase = {
+        [stateKeyA]: findMultipleRelatedKeysState,
+        [stateKeyB]: findMultipleRelatedKeysState
+      };
+      let findState;
+      if (defaultContent) {
+        const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
+        const entriesStateKeyA = `${a}EntriesOf${capitalize(b)}`;
+        const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+        const findStateWithContent = {
+          [entriesStateKeyA]: findMultipleRelatedEntriesState,
+          [entriesStateKeyB]: findMultipleRelatedEntriesState
+        };
+        findState = Object.assign(findStateBase, findStateWithContent);
+      } else {
+        findState = findStateBase;
+      }
+      return {
+        relations,
+        findState
+      };
+    }
+    default:
+      throw new Error(`Invalid cardinality: ${options.cardinality}`);
+  }
+}
+var capitalize2 = (str) => str[0].toUpperCase() + str.slice(1);
+function struct(options, store = internal.IMPLICIT.STORE) {
+  const atoms = Object.keys(options.default).reduce((acc, key) => {
+    const atomName = options.key + capitalize2(key) + `State`;
+    acc[atomName] = internal.createAtom(
+      {
+        key: `${options.key}.${key}`,
+        default: options.default[key]
+      },
+      void 0,
+      store
+    );
+    return acc;
+  }, {});
+  const structState = internal.createSelector(
+    {
+      key: options.key,
+      get: ({ get }) => {
+        return Object.keys(options.default).reduce((acc, key) => {
+          acc[key] = get(atoms[options.key + capitalize2(key) + `State`]);
+          return acc;
+        }, {});
+      }
+    },
+    void 0,
+    store
+  );
+  return [atoms, structState];
+}
+var capitalize3 = (str) => str[0].toUpperCase() + str.slice(1);
+var nameFamily = (topKey, subKey) => `find` + capitalize3(topKey) + capitalize3(subKey) + `State`;
+function structFamily(options) {
+  const atoms = Object.keys(options.default).reduce((acc, subKey) => {
+    const atomFamilyName = nameFamily(options.key, subKey);
+    acc[atomFamilyName] = internal.createAtomFamily(
+      {
+        key: `${options.key}.${subKey}`,
+        default: options.default[subKey]
+      },
+      internal.IMPLICIT.STORE
+    );
+    return acc;
+  }, {});
+  const findStructState = internal.createSelectorFamily(
+    {
+      key: options.key,
+      get: (id) => ({ get }) => {
+        return Object.keys(options.default).reduce((acc, subKey) => {
+          acc[subKey] = get(
+            atoms[nameFamily(options.key, subKey)](id)
+          );
+          return acc;
+        }, {});
+      }
+    },
+    internal.IMPLICIT.STORE
+  );
+  return [atoms, findStructState];
+}
+
+// src/until.ts
+function until(loadable, fallback) {
+  if (loadable instanceof Promise) {
+    return fallback;
+  }
+  return loadable;
+}
+
+exports.dict = dict;
+exports.join = join;
+exports.struct = struct;
+exports.structFamily = structFamily;
+exports.until = until;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map