atom.io 0.0.0

package/dist/index.js

@@ -0,0 +1,923 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  __INTERNAL__: () => internal_exports,
+  atom: () => atom,
+  atomFamily: () => atomFamily,
+  configure: () => configure,
+  getState: () => getState,
+  registerSelector: () => registerSelector,
+  selector: () => selector,
+  selectorFamily: () => selectorFamily,
+  setState: () => setState,
+  subscribe: () => subscribe,
+  transaction: () => transaction
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/internal/index.ts
+var internal_exports = {};
+__export(internal_exports, {
+  IMPLICIT: () => IMPLICIT,
+  abortTransaction: () => abortTransaction,
+  clearStore: () => clearStore,
+  configure: () => configure,
+  createStore: () => createStore,
+  deposit: () => deposit,
+  finishAction: () => finishAction,
+  finishTransaction: () => finishTransaction,
+  getCachedState: () => getCachedState,
+  getSelectorState: () => getSelectorState,
+  getState__INTERNAL: () => getState__INTERNAL,
+  isDone: () => isDone,
+  markDone: () => markDone,
+  propagateChanges: () => propagateChanges,
+  recall: () => recall,
+  setAtomState: () => setAtomState,
+  setSelectorState: () => setSelectorState,
+  setState__INTERNAL: () => setState__INTERNAL,
+  startAction: () => startAction,
+  startTransaction: () => startTransaction,
+  withdraw: () => withdraw
+});
+
+// src/internal/get.ts
+var import_hamt_plus2 = __toESM(require("hamt_plus"));
+
+// src/internal/store.ts
+var import_hamt_plus = __toESM(require("hamt_plus"));
+
+// ../anvl/src/join/core-relation-data.ts
+var import_string = require("fp-ts/string");
+
+// ../anvl/src/array/venn.ts
+var includesAll = (items) => (array) => {
+  for (const item of items) {
+    if (!array.includes(item))
+      return false;
+  }
+  return true;
+};
+var comprises = (items) => (array) => includesAll(items)(array) && includesAll(array)(items);
+
+// ../anvl/src/array/index.ts
+var isArray = (isType) => (input) => Array.isArray(input) && input.every((item) => isType(item));
+var map = (f) => (a) => a.map(f);
+var every = (f = Boolean) => (a) => a.every(f);
+var allTrue = every((x) => x === true);
+var addTo = (a) => (x) => a.includes(x) ? a : [...a, x];
+var isEmptyArray = (input) => Array.isArray(input) && input.length === 0;
+var isOneOf = (...args) => (input) => args.includes(input);
+
+// ../anvl/src/object/refinement.ts
+var import_function2 = require("fp-ts/function");
+
+// ../anvl/src/object/access.ts
+var access = (k) => Object.assign((obj) => obj[k], {
+  in: (obj) => obj[k]
+});
+
+// ../anvl/src/object/entries.ts
+var recordToEntries = (obj) => Object.entries(obj);
+var entriesToRecord = (entries) => Object.fromEntries(entries);
+
+// ../anvl/src/object/mapObject.ts
+var import_function = require("fp-ts/lib/function");
+var mapObject = (obj, fn) => (0, import_function.pipe)(
+  obj,
+  recordToEntries,
+  map(([key, val]) => [key, fn(val, key)]),
+  entriesToRecord
+);
+var mob = (fn) => (obj) => mapObject(obj, fn);
+
+// ../anvl/src/function/index.ts
+var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
+  originalThing instanceof Function ? originalThing() : originalThing
+) : nextVersionOfThing;
+var pass = (...params) => (fn) => fn(...params);
+
+// ../anvl/src/nullish/index.ts
+var isUndefined = (input) => input === void 0;
+var ifNullish = (alt) => (input) => input != null ? input : alt;
+
+// ../anvl/src/object/refinement.ts
+var isNonNullObject = (input) => typeof input === `object` && input !== null;
+var isPlainObject = (input) => isNonNullObject(input) && Object.getPrototypeOf(input) === Object.prototype;
+var isEmptyObject = (input) => isPlainObject(input) && Object.keys(input).length === 0;
+var isRecord = (isKey, isValue) => (input) => isPlainObject(input) && Object.entries(input).every(([k, v]) => isKey(k) && isValue(v));
+var hasProperties = (isValue, options = { allowExtraProperties: false }) => {
+  const name = `{${recordToEntries(
+    isValue
+  ).map(([k, v]) => String(k) + `:` + v.name).join(`,`)}}`;
+  const _ = {
+    [name]: (input) => isPlainObject(input) && (0, import_function2.pipe)(
+      isValue,
+      Object.entries,
+      every(([key, val]) => key in input || val(void 0))
+    ) && (0, import_function2.pipe)(
+      input,
+      mob(
+        (val, key) => (0, import_function2.pipe)(
+          isValue,
+          access(key),
+          ifNullish(() => options.allowExtraProperties),
+          pass(val)
+        )
+      ),
+      Object.values,
+      allTrue
+    )
+  };
+  return _[name];
+};
+var hasExactProperties = (
+  /* alias for hasProperties without allowExtraProperties */
+  (isValue) => hasProperties(isValue, { allowExtraProperties: false })
+);
+
+// ../anvl/src/join/core-relation-data.ts
+var RELATION_TYPES = [`1:1`, `1:n`, `n:n`];
+var isRelationType = (x) => RELATION_TYPES.includes(x);
+var EMPTY_RELATION_DATA = {
+  contents: {},
+  relations: {},
+  relationType: `n:n`
+};
+var isRelationData = (isContent) => (input) => hasExactProperties({
+  contents: isContent ? isRecord(import_string.isString, isContent) : hasExactProperties({}),
+  relations: isRecord(import_string.isString, isArray(import_string.isString)),
+  relationType: isRelationType
+})(input);
+
+// ../anvl/src/join/get-related-ids.ts
+var getRelatedIds = (relationMap, id) => {
+  var _a;
+  return (_a = relationMap.relations[id]) != null ? _a : [];
+};
+var getRelatedId = (relationMap, id) => {
+  const relations = getRelatedIds(relationMap, id);
+  if (relations.length > 1) {
+    console.warn(
+      `entry with id ${id} was not expected to have multiple relations`
+    );
+  }
+  return relations[0];
+};
+
+// ../anvl/src/join/relation-contents.ts
+var import_function6 = require("fp-ts/function");
+
+// ../anvl/src/join/relation-record.ts
+var getRelationEntries = (relationMap, idA) => getRelatedIds(relationMap, idA).map((idB) => [
+  idB,
+  getContent(relationMap, idA, idB)
+]);
+var getRelationRecord = (relationMap, id) => Object.fromEntries(getRelationEntries(relationMap, id));
+
+// ../anvl/src/join/remove-relation.ts
+var import_function5 = require("fp-ts/function");
+var import_string2 = require("fp-ts/string");
+
+// ../anvl/src/object/index.ts
+var import_function4 = require("fp-ts/function");
+var treeShake = (shouldDiscard = isUndefined) => (obj) => {
+  const newObj = {};
+  const entries = Object.entries(obj);
+  entries.forEach(
+    ([key, val]) => !shouldDiscard(val, key) ? newObj[key] = val : null
+  );
+  return newObj;
+};
+
+// ../anvl/src/string/split.ts
+var split = (separator) => (str) => str.split(separator);
+
+// ../anvl/src/join/remove-relation.ts
+var removeSpecific = (current, idA, idB) => {
+  const isIdForRemoval = isOneOf(idA, idB);
+  return __spreadProps(__spreadValues({}, current), {
+    relations: (0, import_function5.pipe)(
+      current.relations,
+      recordToEntries,
+      map(([id, relations]) => [
+        id,
+        isIdForRemoval(id) ? relations.filter((relation) => !isIdForRemoval(relation)) : relations
+      ]),
+      entriesToRecord,
+      treeShake(isEmptyArray)
+    ),
+    contents: (0, import_function5.pipe)(
+      current.contents,
+      treeShake(
+        (_, key) => (0, import_string2.isString)(key) && (0, import_function5.pipe)(key, split(`/`), comprises([idA, idB]))
+      )
+    )
+  });
+};
+var removeAll = (current, idToRemove) => {
+  const next = __spreadProps(__spreadValues({}, current), {
+    relations: (0, import_function5.pipe)(
+      current.relations,
+      recordToEntries,
+      map(([id, relations]) => [
+        id,
+        relations.filter((relation) => relation !== idToRemove)
+      ]),
+      entriesToRecord,
+      treeShake((val, key) => key === idToRemove || isEmptyArray(val))
+    ),
+    contents: (0, import_function5.pipe)(
+      current.contents,
+      treeShake(
+        (_, key) => (0, import_string2.isString)(key) && key.split(`/`).includes(idToRemove)
+      )
+    )
+  });
+  return next;
+};
+var removeRelation = (current, idA, idB) => idB ? removeSpecific(current, idA, idB) : removeAll(current, idA);
+
+// ../anvl/src/join/set-relation.ts
+var setManyToMany = (map2, idA, idB, ...rest) => {
+  var _a, _b;
+  const next = __spreadProps(__spreadValues({}, map2), {
+    relations: __spreadProps(__spreadValues({}, map2.relations), {
+      [idA]: addTo((_a = map2.relations[idA]) != null ? _a : [])(idB),
+      [idB]: addTo((_b = map2.relations[idB]) != null ? _b : [])(idA)
+    })
+  });
+  const content = rest[0];
+  return content ? setContent(next, idA, idB, content) : next;
+};
+var removeEmpties = treeShake(isEmptyArray);
+var set1ToMany = (current, leaderId, followerId, ...rest) => {
+  var _a;
+  const relations = __spreadValues({}, current.relations);
+  const prevLeaderId = getRelatedId(current, followerId);
+  const next = __spreadProps(__spreadValues({}, current), {
+    relations: removeEmpties(__spreadProps(__spreadValues(__spreadValues({}, relations), prevLeaderId && prevLeaderId !== leaderId && {
+      [prevLeaderId]: relations[prevLeaderId].filter(
+        (id) => id !== followerId
+      )
+    }), {
+      [followerId]: [leaderId],
+      [leaderId]: addTo((_a = relations[leaderId]) != null ? _a : [])(followerId)
+    }))
+  });
+  const content = rest[0];
+  return content ? setContent(next, leaderId, followerId, content) : next;
+};
+var set1To1 = (current, wifeId, husbandId, ...rest) => {
+  const prevWifeId = getRelatedId(current, husbandId);
+  const prevHusbandId = getRelatedId(current, wifeId);
+  const next = __spreadProps(__spreadValues({}, current), {
+    relations: removeEmpties(__spreadProps(__spreadValues(__spreadValues(__spreadValues({}, current.relations), prevWifeId && { [prevWifeId]: [] }), prevHusbandId && { [prevHusbandId]: [] }), {
+      [wifeId]: [husbandId],
+      [husbandId]: [wifeId]
+    }))
+  });
+  const content = rest[0];
+  return content ? setContent(next, wifeId, husbandId, content) : next;
+};
+var setRelationWithContent = (current, idA, idB, ...rest) => {
+  switch (current.relationType) {
+    case `1:1`:
+      return set1To1(current, idA, idB, ...rest);
+    case `1:n`:
+      return set1ToMany(current, idA, idB, ...rest);
+    case `n:n`:
+      return setManyToMany(current, idA, idB, ...rest);
+  }
+};
+
+// ../anvl/src/join/relation-contents.ts
+var makeContentId = (idA, idB) => [idA, idB].sort().join(`/`);
+var getContent = (relationMap, idA, idB) => relationMap.contents[makeContentId(idA, idB)];
+var setContent = (map2, idA, idB, content) => __spreadProps(__spreadValues({}, map2), {
+  contents: __spreadProps(__spreadValues({}, map2.contents), {
+    [makeContentId(idA, idB)]: content
+  })
+});
+var getRelations = (relationMap, id) => getRelationEntries(relationMap, id).map(
+  ([id2, content]) => __spreadValues({
+    id: id2
+  }, content)
+);
+var setRelations = (current, idA, relations) => (0, import_function6.pipe)(
+  current,
+  (relationData) => {
+    const relatedIds = getRelatedIds(current, idA);
+    const removedIds = relatedIds.filter(
+      (id) => !relations.some((r) => r.id === id)
+    );
+    let step = relationData;
+    for (const idB of removedIds)
+      step = removeRelation(step, idA, idB);
+    return step;
+  },
+  (relationData) => {
+    let step = relationData;
+    for (const _a of relations) {
+      const _b = _a, { id: idB } = _b, rest = __objRest(_b, ["id"]);
+      const content = isEmptyObject(rest) ? void 0 : rest;
+      step = setRelationWithContent(step, idA, idB, content);
+    }
+    return step;
+  },
+  (relationData) => {
+    const newlyOrderedIds = relations.map((r) => r.id);
+    return __spreadProps(__spreadValues({}, relationData), {
+      relations: __spreadProps(__spreadValues({}, relationData.relations), {
+        [idA]: newlyOrderedIds
+      })
+    });
+  }
+);
+
+// ../anvl/src/refinement/index.ts
+var canExist = (_) => true;
+var cannotExist = (_) => false;
+var couldBe = (isTypeA, logging = false, refinements = [isTypeA]) => {
+  const name = `(${refinements.map((r) => r.name || `anon`).join(` | `)})`;
+  const _ = {
+    [name]: (input) => refinements.some(
+      (refinement) => {
+        var _a;
+        return logging && console.log(
+          refinements.map((r) => r.name || `anon`).join(` | `),
+          `>`,
+          (_a = refinement.name) != null ? _a : `anon`,
+          `:`,
+          refinement(input)
+        ), refinement(input);
+      }
+    )
+  };
+  const checkTypes = Object.assign(_[name], {
+    or: (isTypeB) => couldBe(isTypeB, logging, [...refinements, isTypeB])
+  });
+  return checkTypes;
+};
+var isUnion = couldBe(cannotExist);
+var mustBe = (isTypeA, logging = false, refinements = [isTypeA]) => {
+  const name = `(${refinements.map((r) => r.name || `anon`).join(` & `)})`;
+  const _ = {
+    [name]: (input) => refinements.every(
+      (refinement) => (logging && console.log(
+        refinements.map((r) => r.name || `anon`).join(` & `),
+        `>`,
+        refinement.name || `anon`,
+        `:`,
+        refinement(input)
+      ), refinement(input))
+    )
+  };
+  const checkTypes = Object.assign(_[name], {
+    and: (isTypeB) => mustBe(isTypeB, logging, [...refinements, isTypeB])
+  });
+  return checkTypes;
+};
+var isIntersection = mustBe(canExist);
+
+// ../anvl/src/join/index.ts
+var Join = class {
+  constructor(json) {
+    Object.assign(this, __spreadValues(__spreadValues({}, EMPTY_RELATION_DATA), json));
+  }
+  toJSON() {
+    return {
+      relationType: this.relationType,
+      relations: this.relations,
+      contents: this.contents
+    };
+  }
+  static fromJSON(json, isContent = cannotExist) {
+    const isValid = isRelationData(isContent)(json);
+    if (isValid) {
+      return new Join(json);
+    }
+    throw new Error(
+      `Saved JSON for this Join is invalid: ${JSON.stringify(json)}`
+    );
+  }
+  getRelatedId(id) {
+    return getRelatedId(this, id);
+  }
+  getRelatedIds(id) {
+    return getRelatedIds(this, id);
+  }
+  getContent(idA, idB) {
+    return getContent(this, idA, idB);
+  }
+  getRelationEntries(id) {
+    return getRelationEntries(this, id);
+  }
+  getRelationRecord(id) {
+    return getRelationRecord(this, id);
+  }
+  getRelation(id) {
+    return getRelations(this, id)[0];
+  }
+  getRelations(id) {
+    return getRelations(this, id);
+  }
+  setRelations(id, relations) {
+    return new Join(setRelations(this, id, relations));
+  }
+  set(idA, idB, ...rest) {
+    return new Join(setRelationWithContent(this, idA, idB, ...rest));
+  }
+  remove(idA, idB) {
+    return new Join(removeRelation(this, idA, idB));
+  }
+};
+
+// src/internal/store.ts
+var createStore = (name) => ({
+  valueMap: import_hamt_plus.default.make(),
+  selectorGraph: new Join({ relationType: `n:n` }),
+  atoms: import_hamt_plus.default.make(),
+  selectors: import_hamt_plus.default.make(),
+  readonlySelectors: import_hamt_plus.default.make(),
+  operation: {
+    open: false
+  },
+  transaction: {
+    open: false
+  },
+  config: {
+    name,
+    logger: null
+  }
+});
+var IMPLICIT = {
+  STORE_INTERNAL: void 0,
+  get STORE() {
+    var _a;
+    return (_a = this.STORE_INTERNAL) != null ? _a : this.STORE_INTERNAL = createStore(`DEFAULT`);
+  }
+};
+var configure = (config, store = IMPLICIT.STORE) => {
+  Object.assign(store.config, config);
+};
+var clearStore = (store = IMPLICIT.STORE) => {
+  const { config } = store;
+  Object.assign(store, createStore(config.name));
+  store.config = config;
+};
+
+// src/internal/get.ts
+var getCachedState = (state, store = IMPLICIT.STORE) => {
+  const value = import_hamt_plus2.default.get(state.key, store.valueMap);
+  return value;
+};
+var getSelectorState = (selector2) => selector2.get();
+function withdraw(token, store) {
+  var _a, _b;
+  return (_b = (_a = import_hamt_plus2.default.get(token.key, store.atoms)) != null ? _a : import_hamt_plus2.default.get(token.key, store.selectors)) != null ? _b : import_hamt_plus2.default.get(token.key, store.readonlySelectors);
+}
+function deposit(state) {
+  if (`get` in state) {
+    if (`set` in state) {
+      return { key: state.key, type: `selector` };
+    }
+    return { key: state.key, type: `readonly_selector` };
+  }
+  return { key: state.key, type: `atom` };
+}
+var getState__INTERNAL = (state, store = IMPLICIT.STORE) => {
+  var _a;
+  if (import_hamt_plus2.default.has(state.key, store.valueMap)) {
+    return getCachedState(state, store);
+  }
+  if (`get` in state) {
+    return getSelectorState(state);
+  }
+  (_a = store.config.logger) == null ? void 0 : _a.error(
+    `Attempted to get atom "${state.key}", which was never initialized in store "${store.config.name}".`
+  );
+  return state.default;
+};
+
+// src/internal/set.ts
+var import_hamt_plus4 = __toESM(require("hamt_plus"));
+
+// src/internal/operation.ts
+var import_hamt_plus3 = __toESM(require("hamt_plus"));
+var finishAction = (store) => {
+  var _a;
+  store.operation = { open: false };
+  (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2705`, `operation complete`);
+};
+var startAction = (store) => {
+  var _a;
+  store.operation = {
+    open: true,
+    done: /* @__PURE__ */ new Set(),
+    prev: store.valueMap
+  };
+  (_a = store.config.logger) == null ? void 0 : _a.info(`   \u26A0\uFE0F`, `action started`);
+};
+var isDone = (key, store = IMPLICIT.STORE) => {
+  var _a;
+  if (!store.operation.open) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `isDone called outside of an action. This is probably a bug.`
+    );
+    return true;
+  }
+  return store.operation.done.has(key);
+};
+var markDone = (key, store = IMPLICIT.STORE) => {
+  var _a;
+  if (!store.operation.open) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `markDone called outside of an action. This is probably a bug.`
+    );
+    return;
+  }
+  store.operation.done.add(key);
+};
+var recall = (state, store = IMPLICIT.STORE) => {
+  var _a;
+  if (!store.operation.open) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `recall called outside of an action. This is probably a bug.`
+    );
+    return import_hamt_plus3.default.get(state.key, store.valueMap);
+  }
+  return import_hamt_plus3.default.get(state.key, store.operation.prev);
+};
+
+// src/internal/set.ts
+var propagateChanges = (state, store = IMPLICIT.STORE) => {
+  var _a, _b;
+  const relatedStateKeys = store.selectorGraph.getRelations(state.key);
+  (_a = store.config.logger) == null ? void 0 : _a.info(
+    `   ||`,
+    `bumping`,
+    relatedStateKeys.length,
+    `states:`,
+    relatedStateKeys.map(({ id }) => id)
+  );
+  if (store.operation.open) {
+    (_b = store.config.logger) == null ? void 0 : _b.info(`   ||`, `done:`, store.operation.done);
+  }
+  relatedStateKeys.forEach(({ id: stateKey }) => {
+    var _a2, _b2, _c, _d;
+    if (isDone(stateKey, store)) {
+      (_a2 = store.config.logger) == null ? void 0 : _a2.info(`   ||`, stateKey, `already done`);
+      return;
+    }
+    (_b2 = store.config.logger) == null ? void 0 : _b2.info(`->`, `bumping`, stateKey);
+    store.valueMap = import_hamt_plus4.default.remove(stateKey, store.valueMap);
+    const state2 = (_c = import_hamt_plus4.default.get(stateKey, store.selectors)) != null ? _c : import_hamt_plus4.default.get(stateKey, store.readonlySelectors);
+    const newValue = getState__INTERNAL(state2, store);
+    (_d = store.config.logger) == null ? void 0 : _d.info(`   <-`, stateKey, `became`, newValue);
+    const oldValue = recall(state2, store);
+    state2.subject.next({ newValue, oldValue });
+    markDone(stateKey, store);
+    if (`set` in state2)
+      propagateChanges(state2, store);
+  });
+};
+var setAtomState = (atom2, next, store = IMPLICIT.STORE) => {
+  var _a, _b;
+  const oldValue = getState__INTERNAL(atom2, store);
+  const newValue = become(next)(oldValue);
+  (_a = store.config.logger) == null ? void 0 : _a.info(
+    `->`,
+    `setting atom`,
+    `"${atom2.key}"`,
+    `to`,
+    newValue
+  );
+  store.valueMap = import_hamt_plus4.default.set(atom2.key, newValue, store.valueMap);
+  markDone(atom2.key, store);
+  atom2.subject.next({ newValue, oldValue });
+  (_b = store.config.logger) == null ? void 0 : _b.info(`   ||`, `propagating change to`, `"${atom2.key}"`);
+  propagateChanges(atom2, store);
+};
+var setSelectorState = (selector2, next, store = IMPLICIT.STORE) => {
+  var _a, _b;
+  const oldValue = getState__INTERNAL(selector2, store);
+  const newValue = become(next)(oldValue);
+  (_a = store.config.logger) == null ? void 0 : _a.info(
+    `->`,
+    `setting selector`,
+    `"${selector2.key}"`,
+    `to`,
+    newValue
+  );
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    `   ||`,
+    `propagating change to`,
+    `"${selector2.key}"`
+  );
+  selector2.set(newValue);
+  markDone(selector2.key, store);
+  propagateChanges(selector2, store);
+};
+var setState__INTERNAL = (token, value, store = IMPLICIT.STORE) => {
+  const state = withdraw(token, store);
+  if (`set` in state) {
+    setSelectorState(state, value, store);
+  } else {
+    setAtomState(state, value, store);
+  }
+};
+
+// src/internal/transaction-internal.ts
+var finishTransaction = (store) => {
+  var _a;
+  store.transaction = { open: false };
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F4B8}`, `transaction done`);
+};
+var startTransaction = (store) => {
+  var _a;
+  store.transaction = {
+    open: true,
+    prev: {
+      atoms: store.atoms,
+      readonlySelectors: store.readonlySelectors,
+      selectorGraph: store.selectorGraph,
+      selectors: store.selectors,
+      valueMap: store.valueMap
+    }
+  };
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u{1F3E6}`, `transaction start`);
+};
+var abortTransaction = (store) => {
+  var _a, _b;
+  if (!store.transaction.open) {
+    (_a = store.config.logger) == null ? void 0 : _a.warn(
+      `abortTransaction called outside of a transaction. This is probably a bug.`
+    );
+    return;
+  }
+  store.atoms = store.transaction.prev.atoms;
+  store.readonlySelectors = store.transaction.prev.readonlySelectors;
+  store.selectorGraph = store.transaction.prev.selectorGraph;
+  store.selectors = store.transaction.prev.selectors;
+  store.valueMap = store.transaction.prev.valueMap;
+  store.transaction = { open: false };
+  (_b = store.config.logger) == null ? void 0 : _b.info(`\u{1FA82}`, `transaction fail`);
+};
+
+// src/atom.ts
+var import_hamt_plus5 = __toESM(require("hamt_plus"));
+var Rx = __toESM(require("rxjs"));
+
+// ../anvl/src/json/index.ts
+var import_function8 = require("fp-ts/function");
+var stringifyJson = (json) => JSON.stringify(json);
+
+// src/atom.ts
+var atom = (options, store = IMPLICIT.STORE) => {
+  var _a, _b, _c;
+  if (import_hamt_plus5.default.has(options.key, store.atoms)) {
+    (_b = (_a = store.config.logger) == null ? void 0 : _a.error) == null ? void 0 : _b.call(
+      _a,
+      `Key "${options.key}" already exists in the store.`
+    );
+    return deposit(store.atoms.get(options.key));
+  }
+  const subject = new Rx.Subject();
+  const newAtom = __spreadProps(__spreadValues({}, options), { subject });
+  store.atoms = import_hamt_plus5.default.set(options.key, newAtom, store.atoms);
+  store.valueMap = import_hamt_plus5.default.set(options.key, options.default, store.valueMap);
+  const token = deposit(newAtom);
+  const setSelf = (next) => setState(token, next, store);
+  const onSet = (observe) => subscribe(token, observe, store);
+  setSelf(options.default);
+  (_c = options.effects) == null ? void 0 : _c.forEach((effect) => effect({ setSelf, onSet }));
+  return token;
+};
+var atomFamily = (options, store = IMPLICIT.STORE) => (key) => {
+  var _a;
+  const fullKey = `${options.key}__${stringifyJson(key)}`;
+  const existing = store.atoms.get(fullKey);
+  if (existing) {
+    return deposit(existing);
+  }
+  return atom(
+    {
+      key: fullKey,
+      default: options.default instanceof Function ? options.default(key) : options.default,
+      effects: (_a = options.effects) == null ? void 0 : _a.call(options, key)
+    },
+    store
+  );
+};
+
+// src/selector.ts
+var import_hamt_plus6 = __toESM(require("hamt_plus"));
+var Rx2 = __toESM(require("rxjs"));
+function selector(options, store = IMPLICIT.STORE) {
+  var _a, _b;
+  if (import_hamt_plus6.default.has(options.key, store.selectors)) {
+    throw new Error(`Key "${options.key}" already exists in the store.`);
+  }
+  const subject = new Rx2.Subject();
+  const { get, set } = registerSelector(options.key, store);
+  const getSelf = () => {
+    const value = options.get({ get });
+    store.valueMap = import_hamt_plus6.default.set(options.key, value, store.valueMap);
+    return value;
+  };
+  if (!(`set` in options)) {
+    const readonlySelector = __spreadProps(__spreadValues({}, options), {
+      subject,
+      get: getSelf
+    });
+    store.readonlySelectors = import_hamt_plus6.default.set(
+      options.key,
+      readonlySelector,
+      store.readonlySelectors
+    );
+    const initialValue2 = getSelf();
+    (_a = store.config.logger) == null ? void 0 : _a.info(`   \u2728`, options.key, `=`, initialValue2);
+    return __spreadProps(__spreadValues({}, readonlySelector), { type: `readonly_selector` });
+  }
+  const setSelf = (next) => {
+    var _a2;
+    (_a2 = store.config.logger) == null ? void 0 : _a2.info(`${options.key}.set`, next);
+    const oldValue = getSelf();
+    const newValue = become(next)(oldValue);
+    store.valueMap = import_hamt_plus6.default.set(options.key, newValue, store.valueMap);
+    console.error({ oldValue });
+    subject.next({ newValue, oldValue });
+    options.set({ get, set }, newValue);
+  };
+  const mySelector = __spreadProps(__spreadValues({}, options), {
+    subject,
+    get: getSelf,
+    set: setSelf
+  });
+  store.selectors = import_hamt_plus6.default.set(options.key, mySelector, store.selectors);
+  const initialValue = getSelf();
+  (_b = store.config.logger) == null ? void 0 : _b.info(`   \u2728`, options.key, `=`, initialValue);
+  return __spreadProps(__spreadValues({}, mySelector), { type: `selector` });
+}
+function selectorFamily(options, store = IMPLICIT.STORE) {
+  return (key) => {
+    var _a;
+    const fullKey = `${options.key}__${stringifyJson(key)}`;
+    const existing = (_a = store.selectors.get(fullKey)) != null ? _a : store.readonlySelectors.get(fullKey);
+    if (existing) {
+      return deposit(existing);
+    }
+    const readonlySelectorOptions = {
+      key: fullKey,
+      get: options.get(key)
+    };
+    if (!(`set` in options)) {
+      return selector(
+        __spreadValues({}, readonlySelectorOptions),
+        store
+      );
+    }
+    return selector(
+      __spreadProps(__spreadValues({}, readonlySelectorOptions), {
+        set: options.set(key)
+      }),
+      store
+    );
+  };
+}
+var registerSelector = (selectorKey, store = IMPLICIT.STORE) => ({
+  get: (state) => {
+    var _a, _b, _c;
+    const isRegistered = store.selectorGraph.getRelatedIds(selectorKey).includes(state.key);
+    if (isRegistered) {
+      (_a = store.config.logger) == null ? void 0 : _a.info(`   ||`, selectorKey, `<-`, state.key);
+    } else {
+      (_b = store.config.logger) == null ? void 0 : _b.info(
+        `\u{1F50C} registerSelector`,
+        state.key,
+        `->`,
+        selectorKey
+      );
+      store.selectorGraph = store.selectorGraph.set(selectorKey, state.key);
+    }
+    const currentValue = getState(state, store);
+    (_c = store.config.logger) == null ? void 0 : _c.info(`   ||`, state.key, `=`, currentValue);
+    return currentValue;
+  },
+  set: (token, newValue) => {
+    store.selectorGraph.set(token.key, selectorKey);
+    setState__INTERNAL(token, newValue, store);
+  }
+});
+
+// src/transaction.ts
+var transaction = (options, store = IMPLICIT.STORE) => Object.assign(
+  (...parameters) => {
+    var _a;
+    startTransaction(store);
+    try {
+      const result = options.do(
+        {
+          get: (token) => getState(token, store),
+          set: (token, value) => setState(token, value, store)
+        },
+        ...parameters
+      );
+      finishTransaction(store);
+      return result;
+    } catch (thrown) {
+      abortTransaction(store);
+      (_a = store.config.logger) == null ? void 0 : _a.error(`Transaction ${options.key} failed`, thrown);
+      throw thrown;
+    }
+  },
+  { key: options.key }
+);
+
+// src/index.ts
+var getState = (token, store = IMPLICIT.STORE) => {
+  const state = withdraw(token, store);
+  return getState__INTERNAL(state, store);
+};
+var setState = (state, value, store = IMPLICIT.STORE) => {
+  startAction(store);
+  setState__INTERNAL(state, value, store);
+  finishAction(store);
+};
+var subscribe = (token, observe, store = IMPLICIT.STORE) => {
+  const state = withdraw(token, store);
+  const subscription = state.subject.subscribe(observe);
+  return () => subscription.unsubscribe();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __INTERNAL__,
+  atom,
+  atomFamily,
+  configure,
+  getState,
+  registerSelector,
+  selector,
+  selectorFamily,
+  setState,
+  subscribe,
+  transaction
+});