atom.io 0.0.0 → 0.1.0

package/dist/react/index.mjs

@@ -0,0 +1,751 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+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 });
+};
+
+// src/react/useSubject.ts
+var eq = (oldValue, newValue) => oldValue === newValue;
+var composeSubjectHook = (useState, useEffect) => {
+  function useSubject(subject, initialValue, compareFn = eq) {
+    const [state, setState2] = useState(initialValue);
+    useEffect(() => {
+      const subscription = subject.subscribe(({ newValue, oldValue }) => {
+        if (!compareFn(oldValue, newValue)) {
+          setState2(newValue);
+        }
+      });
+      return () => {
+        subscription.unsubscribe();
+      };
+    }, [state, compareFn, subject]);
+    const updateState = (newValue) => {
+      subject.next({ newValue, oldValue: state });
+    };
+    return [state, updateState];
+  }
+  return useSubject;
+};
+
+// 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,
+  propagateDown: () => propagateDown,
+  recall: () => recall,
+  setAtomState: () => setAtomState,
+  setSelectorState: () => setSelectorState,
+  setState__INTERNAL: () => setState__INTERNAL,
+  startAction: () => startAction,
+  startTransaction: () => startTransaction,
+  withdraw: () => withdraw
+});
+
+// src/internal/get.ts
+import HAMT2 from "hamt_plus";
+
+// src/internal/store.ts
+import HAMT from "hamt_plus";
+
+// ../anvl/src/join/core-relation-data.ts
+import { isString } from "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
+import { pipe as pipe2 } from "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
+import { pipe } from "fp-ts/lib/function";
+var mapObject = (obj, fn) => 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) && pipe2(
+      isValue,
+      Object.entries,
+      every(([key, val]) => key in input || val(void 0))
+    ) && pipe2(
+      input,
+      mob(
+        (val, key) => pipe2(
+          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(isString, isContent) : hasExactProperties({}),
+  relations: isRecord(isString, isArray(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
+import { pipe as pipe5 } from "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
+import { pipe as pipe4 } from "fp-ts/function";
+import { isString as isString2 } from "fp-ts/string";
+
+// ../anvl/src/object/index.ts
+import { pipe as pipe3 } from "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: pipe4(
+      current.relations,
+      recordToEntries,
+      map(([id, relations]) => [
+        id,
+        isIdForRemoval(id) ? relations.filter((relation) => !isIdForRemoval(relation)) : relations
+      ]),
+      entriesToRecord,
+      treeShake(isEmptyArray)
+    ),
+    contents: pipe4(
+      current.contents,
+      treeShake(
+        (_, key) => isString2(key) && pipe4(key, split(`/`), comprises([idA, idB]))
+      )
+    )
+  });
+};
+var removeAll = (current, idToRemove) => {
+  const next = __spreadProps(__spreadValues({}, current), {
+    relations: pipe4(
+      current.relations,
+      recordToEntries,
+      map(([id, relations]) => [
+        id,
+        relations.filter((relation) => relation !== idToRemove)
+      ]),
+      entriesToRecord,
+      treeShake((val, key) => key === idToRemove || isEmptyArray(val))
+    ),
+    contents: pipe4(
+      current.contents,
+      treeShake(
+        (_, key) => isString2(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) => pipe5(
+  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: HAMT.make(),
+  selectorGraph: new Join({ relationType: `n:n` }),
+  atoms: HAMT.make(),
+  selectors: HAMT.make(),
+  readonlySelectors: HAMT.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 = HAMT2.get(state.key, store.valueMap);
+  return value;
+};
+var getSelectorState = (selector) => selector.get();
+function withdraw(token, store) {
+  var _a, _b;
+  return (_b = (_a = HAMT2.get(token.key, store.atoms)) != null ? _a : HAMT2.get(token.key, store.selectors)) != null ? _b : HAMT2.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 (HAMT2.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
+import HAMT4 from "hamt_plus";
+
+// src/internal/operation.ts
+import HAMT3 from "hamt_plus";
+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(`\u2610`, `operation start`);
+};
+var finishAction = (store) => {
+  var _a;
+  store.operation = { open: false };
+  (_a = store.config.logger) == null ? void 0 : _a.info(`\u2611\uFE0F`, `operation done`);
+};
+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 HAMT3.get(state.key, store.valueMap);
+  }
+  return HAMT3.get(state.key, store.operation.prev);
+};
+
+// src/internal/set.ts
+var propagateDown = (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, _e;
+    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);
+    const state2 = (_c = HAMT4.get(stateKey, store.selectors)) != null ? _c : HAMT4.get(stateKey, store.readonlySelectors);
+    if (!state2) {
+      (_d = store.config.logger) == null ? void 0 : _d.info(
+        `   ||`,
+        stateKey,
+        `is an atom - no need to propagate down`
+      );
+      return;
+    }
+    store.valueMap = HAMT4.remove(stateKey, store.valueMap);
+    const newValue = getState__INTERNAL(state2, store);
+    (_e = store.config.logger) == null ? void 0 : _e.info(`   <-`, stateKey, `became`, newValue);
+    const oldValue = recall(state2, store);
+    state2.subject.next({ newValue, oldValue });
+    markDone(stateKey, store);
+    if (`set` in state2)
+      propagateDown(state2, store);
+  });
+};
+var setAtomState = (atom, next, store = IMPLICIT.STORE) => {
+  var _a, _b;
+  const oldValue = getState__INTERNAL(atom, store);
+  const newValue = become(next)(oldValue);
+  (_a = store.config.logger) == null ? void 0 : _a.info(
+    `->`,
+    `setting atom`,
+    `"${atom.key}"`,
+    `to`,
+    newValue
+  );
+  store.valueMap = HAMT4.set(atom.key, newValue, store.valueMap);
+  markDone(atom.key, store);
+  atom.subject.next({ newValue, oldValue });
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    `   ||`,
+    `propagating change made to`,
+    `"${atom.key}"`
+  );
+  propagateDown(atom, store);
+};
+var setSelectorState = (selector, next, store = IMPLICIT.STORE) => {
+  var _a, _b;
+  const oldValue = getState__INTERNAL(selector, store);
+  const newValue = become(next)(oldValue);
+  (_a = store.config.logger) == null ? void 0 : _a.info(
+    `->`,
+    `setting selector`,
+    `"${selector.key}"`,
+    `to`,
+    newValue
+  );
+  (_b = store.config.logger) == null ? void 0 : _b.info(
+    `   ||`,
+    `propagating change made to`,
+    `"${selector.key}"`
+  );
+  selector.set(newValue);
+  propagateDown(selector, 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{1F6EC}`, `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{1F6EB}`, `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/index.ts
+var setState = (state, value, store = IMPLICIT.STORE) => {
+  startAction(store);
+  setState__INTERNAL(state, value, store);
+  finishAction(store);
+};
+
+// src/react/index.ts
+var composeStoreHook = ({
+  useState,
+  useEffect,
+  store = internal_exports.IMPLICIT.STORE
+}) => {
+  const useSubject = composeSubjectHook(useState, useEffect);
+  function useStore(token) {
+    const { type } = token;
+    const state = withdraw(token, store);
+    const initialValue = internal_exports.getState__INTERNAL(state, store);
+    const [value] = useSubject(state.subject, initialValue);
+    if (type === `readonly_selector`) {
+      return value;
+    }
+    const updateState = (next) => setState(token, next, store);
+    return [value, updateState];
+  }
+  return { useStore };
+};
+export {
+  composeStoreHook
+};
+//# sourceMappingURL=index.mjs.map