atom.io 0.22.0 → 0.23.1

package/immortal/dist/index.cjs

@@ -1,42 +1,96 @@
 'use strict';
 
-var atom_io = require('atom.io');
-var data = require('atom.io/data');
-var internal = require('atom.io/internal');
+var Internal = require('atom.io/internal');
 var json = require('atom.io/json');
+var data = require('atom.io/data');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var Internal__namespace = /*#__PURE__*/_interopNamespace(Internal);
 
-// immortal/src/molecule.ts
+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 Molecule = class _Molecule {
-  constructor(key, above = [], store = internal.IMPLICIT.STORE) {
-    this.key = key;
-    this.above = above;
+  constructor(store, above, token) {
     this.store = store;
+    this.token = token;
+    this.type = `molecule`;
     this.below = [];
     this.tokens = [];
     this.joins = [];
+    this.subject = new Internal.Subject();
     this.dispose = this[Symbol.dispose];
-    store.molecules.set(json.stringifyJson(key), this);
-    for (const parent of above) {
-      parent.below.push(this);
+    if (above) {
+      if (Array.isArray(above)) {
+        this.above = above;
+        for (const parent of above) {
+          parent.below.push(this);
+        }
+      } else {
+        this.above = [above];
+        above.below.push(this);
+      }
+    } else {
+      this.above = [];
     }
   }
+  get key() {
+    return this.token.key;
+  }
   bond(token) {
-    const state = internal.initFamilyMember(token, this.key, this.store);
+    const state = Internal.initFamilyMember(token, this.token.key, this.store);
     if (token.type === `mutable_atom_family`) {
-      const jsonFamily = internal.getJsonFamily(token, this.store);
-      const jsonState = internal.initFamilyMember(jsonFamily, this.key, this.store);
+      const jsonFamily = Internal.getJsonFamily(token, this.store);
+      const jsonState = Internal.initFamilyMember(jsonFamily, this.token.key, this.store);
       this.tokens.push(jsonState);
     }
     this.tokens.push(state);
+    this.subject.next({ type: `state_creation`, token: state });
     return state;
   }
   spawn(key) {
-    const child = new _Molecule(key, [this], this.store);
+    const child = new _Molecule(this.store, this, { key, type: `molecule` });
     return child;
   }
   with(molecule) {
     return (key) => {
-      const child = new _Molecule(key, [this, molecule], this.store);
+      const child = new _Molecule(this.store, [this, molecule], {
+        key,
+        type: `molecule`
+      });
       return child;
     };
   }
@@ -68,33 +122,139 @@ var Molecule = class _Molecule {
     while (this.tokens.length > 0) {
       const token = this.tokens.pop();
       if (token) {
-        atom_io.disposeState(token, this.store);
+        Internal.disposeFromStore(token, this.store);
       }
     }
     while (this.joins.length > 0) {
       const join = this.joins.pop();
       if (join) {
-        join.molecules.delete(json.stringifyJson(this.key));
+        join.molecules.delete(json.stringifyJson(this.token.key));
       }
     }
   }
   join(token) {
     const join = data.getJoin(token, this.store);
-    join.molecules.set(json.stringifyJson(this.key), this);
+    join.molecules.set(json.stringifyJson(this.token.key), this);
     this.joins.push(join);
   }
   [Symbol.dispose]() {
     this.clear();
-    this.store.molecules.delete(json.stringifyJson(this.key));
+    const target = Internal.newest(this.store);
+    target.molecules.delete(json.stringifyJson(this.token.key));
     for (const parent of this.above) {
       parent.detach(this);
     }
   }
 };
+
+// immortal/src/make-molecule.ts
+function createMoleculeFamily(options, store) {
+  const subject = new Internal__namespace.Subject();
+  const token = {
+    key: options.key,
+    type: `molecule_family`
+  };
+  const family = Object.assign(options.new(store), __spreadProps(__spreadValues({}, token), { subject }));
+  store.moleculeFamilies.set(options.key, family);
+  return token;
+}
+function moleculeFamily(options) {
+  return createMoleculeFamily(options, Internal__namespace.IMPLICIT.STORE);
+}
+function makeMoleculeInStore(store, context, family, key, ...params) {
+  const target = Internal__namespace.newest(store);
+  const token = {
+    type: `molecule`,
+    key,
+    family
+  };
+  const contextArray = Array.isArray(context) ? context : [context];
+  const owners = contextArray.map((ctx) => store.molecules.get(json.stringifyJson(ctx.key))).filter((m) => m !== void 0);
+  const Formula = Internal__namespace.withdraw(family, store);
+  const molecule = new Formula(owners, token, ...params);
+  target.molecules.set(json.stringifyJson(key), molecule);
+  const update = {
+    type: `molecule_creation`,
+    token,
+    family,
+    context: contextArray,
+    params
+  };
+  const isTransaction = Internal__namespace.isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(update);
+  } else {
+    Formula.subject.next(update);
+  }
+  return token;
+}
+function makeMolecule(context, family, key, ...params) {
+  return makeMoleculeInStore(
+    Internal__namespace.IMPLICIT.STORE,
+    context,
+    family,
+    key,
+    ...params
+  );
+}
+function useMoleculeFromStore(token, store) {
+  const molecule = store.molecules.get(json.stringifyJson(token.key));
+  return molecule;
+}
+function useMolecule(token) {
+  return useMoleculeFromStore(token, Internal__namespace.IMPLICIT.STORE);
+}
+function disposeMolecule(token, store) {
+  const mole = useMoleculeFromStore(token, store);
+  if (!mole || !token.family) {
+    return;
+  }
+  const { family } = token;
+  const Formula = Internal__namespace.withdraw(family, store);
+  const disposalEvent = {
+    type: `molecule_disposal`,
+    token,
+    family,
+    context: mole.above,
+    familyKeys: mole.tokens.map((t) => {
+      var _a;
+      return (_a = t.family) == null ? void 0 : _a.key;
+    }).filter((k) => typeof k === `string`)
+  };
+  if (token.family) {
+    disposalEvent.family = token.family;
+  }
+  const isTransaction = Internal__namespace.isChildStore(store) && store.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    store.transactionMeta.update.updates.push(disposalEvent);
+  } else {
+    Formula.subject.next(disposalEvent);
+  }
+  mole.dispose();
+}
+function makeRootMolecule(key, store = Internal__namespace.IMPLICIT.STORE) {
+  const molecule = new Molecule(store, void 0, { key, type: `molecule` });
+  store.molecules.set(json.stringifyJson(key), molecule);
+  return {
+    key,
+    type: `molecule`
+  };
+}
 function seekState(token, key) {
-  const state = internal.seekInStore(token, key, internal.IMPLICIT.STORE);
+  if (token.type === `molecule_family`) {
+    return Internal.seekInStore(token, key, Internal.IMPLICIT.STORE);
+  }
+  const state = Internal.seekInStore(token, key, Internal.IMPLICIT.STORE);
   return state;
 }
 
 exports.Molecule = Molecule;
+exports.createMoleculeFamily = createMoleculeFamily;
+exports.disposeMolecule = disposeMolecule;
+exports.makeMolecule = makeMolecule;
+exports.makeMoleculeInStore = makeMoleculeInStore;
+exports.makeRootMolecule = makeRootMolecule;
+exports.moleculeFamily = moleculeFamily;
 exports.seekState = seekState;
+exports.useMolecule = useMolecule;
+exports.useMoleculeFromStore = useMoleculeFromStore;

package/immortal/dist/index.d.ts

@@ -0,0 +1,103 @@
+import { ReadableToken, StateCreation, StateDisposal, MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, Flat, MoleculeCreation, MoleculeDisposal } from 'atom.io';
+import * as Internal from 'atom.io/internal';
+import { Store, Subject, Transceiver } from 'atom.io/internal';
+import { Json } from 'atom.io/json';
+import { Join, JoinToken } from 'atom.io/data';
+
+declare class Molecule<Key extends Json.Serializable> {
+    readonly store: Store;
+    readonly token: MoleculeToken<Key, any, any>;
+    readonly type = "molecule";
+    get key(): Key;
+    readonly family?: MoleculeFamilyToken<Key, any, any>;
+    readonly above: Molecule<any>[];
+    readonly below: Molecule<any>[];
+    readonly tokens: ReadableToken<any>[];
+    readonly joins: Join<any, any, any, any>[];
+    readonly subject: Subject<StateCreation<any> | StateDisposal<any>>;
+    constructor(store: Store, above: Molecule<any> | Molecule<any>[] | undefined, token: MoleculeToken<Key, any, any>);
+    bond<T extends Transceiver<any>, J extends Json.Serializable, K extends string>(token: MutableAtomFamilyToken<T, J, K>): MutableAtomToken<T, J>;
+    bond<T, K extends Key>(token: RegularAtomFamilyToken<T, K>): RegularAtomToken<T>;
+    bond<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>): WritableSelectorToken<T>;
+    bond<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>): ReadonlySelectorToken<T>;
+    bond<T, K extends Json.Serializable>(token: WritableFamilyToken<T, K>): WritableToken<T>;
+    bond<T, K extends Json.Serializable>(token: ReadableFamilyToken<T, K>): ReadableToken<T>;
+    spawn<K extends Json.Serializable>(key: K): Molecule<K>;
+    with(molecule: Molecule<any>): (key: string) => Molecule<any>;
+    detach(child: Molecule<any>): void;
+    claim(child: Molecule<any>): void;
+    clear(): void;
+    join(token: JoinToken<any, any, any, any>): void;
+    private [Symbol.dispose];
+    dispose: () => void;
+}
+
+type MoleculeConstructor<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]> = new (context: Molecule<any>[], token: MoleculeToken<Key, Struct, Params>, ...params: Params) => Molecule<Key> & Struct;
+type MoleculeFamilyToken<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]> = {
+    key: string;
+    type: `molecule_family`;
+    __K?: Key;
+    __S?: Struct;
+    __P?: Params;
+};
+type MoleculeFamily<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]> = Flat<MoleculeFamilyToken<Key, Struct, Params> & {
+    subject: Internal.Subject<MoleculeCreation<Key> | MoleculeDisposal<Key>>;
+}> & MoleculeConstructor<Key, Struct, Params>;
+type MoleculeToken<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]> = {
+    key: Key;
+    type: `molecule`;
+    family?: MoleculeFamilyToken<Key, Struct, Params>;
+    __S?: Struct;
+    __P?: Params;
+};
+type MoleculeFamilyOptions<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]> = {
+    key: string;
+    new: (store: Internal.Store) => MoleculeConstructor<Key, Struct, Params>;
+};
+declare function createMoleculeFamily<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]>(options: MoleculeFamilyOptions<Key, Struct, Params>, store: Internal.Store): MoleculeFamilyToken<Key, Struct, Params>;
+declare function moleculeFamily<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]>(options: MoleculeFamilyOptions<Key, Struct, Params>): MoleculeFamilyToken<Key, Struct, Params>;
+declare function makeMoleculeInStore<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]>(store: Internal.Store, context: MoleculeToken<any, any, any> | MoleculeToken<any, any, any>[], family: MoleculeFamilyToken<Key, Struct, Params>, key: Key, ...params: Params): MoleculeToken<Key, Struct, Params>;
+declare function makeMolecule<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]>(context: MoleculeToken<any, any, any> | MoleculeToken<any, any, any>[], family: MoleculeFamilyToken<Key, Struct, Params>, key: Key, ...params: Params): MoleculeToken<Key, Struct, Params>;
+declare function useMoleculeFromStore<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]>(token: MoleculeToken<Key, Struct, Params>, store: Internal.Store): (Molecule<Key> & Struct) | undefined;
+declare function useMolecule<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]>(token: MoleculeToken<Key, Struct, Params>): (Molecule<Key> & Struct) | undefined;
+declare function disposeMolecule<Key extends Json.Serializable, Struct extends {
+    [key: string]: any;
+}, Params extends any[]>(token: MoleculeToken<Key, Struct, Params>, store: Internal.Store): void;
+type MoleculeType<M extends MoleculeFamilyToken<any, any, any>> = M extends MoleculeFamilyToken<any, infer T, any> ? T : never;
+declare function makeRootMolecule(key: Json.Serializable, store?: Internal.Store): MoleculeToken<Json.Serializable, {
+    [key: string]: unknown;
+}, []>;
+
+declare function seekState<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J> | undefined;
+declare function seekState<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T> | undefined;
+declare function seekState<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T> | undefined;
+declare function seekState<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T> | undefined;
+declare function seekState<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T> | undefined;
+declare function seekState<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T> | undefined;
+declare function seekState<K extends Json.Serializable, S extends {
+    [key: string]: any;
+}>(token: MoleculeFamilyToken<K, S, any[]>, key: K): MoleculeToken<K, S, any[]> | undefined;
+
+export { Molecule, type MoleculeConstructor, type MoleculeFamily, type MoleculeFamilyOptions, type MoleculeFamilyToken, type MoleculeToken, type MoleculeType, createMoleculeFamily, disposeMolecule, makeMolecule, makeMoleculeInStore, makeRootMolecule, moleculeFamily, seekState, useMolecule, useMoleculeFromStore };

package/immortal/dist/index.js

@@ -1,40 +1,57 @@
-import '../../dist/chunk-F2X4B4VY.js';
-import { disposeState } from 'atom.io';
-import { getJoin } from 'atom.io/data';
-import { IMPLICIT, initFamilyMember, getJsonFamily, seekInStore } from 'atom.io/internal';
+import { __spreadProps, __spreadValues } from '../../dist/chunk-F2X4B4VY.js';
+import * as Internal from 'atom.io/internal';
+import { Subject, initFamilyMember, getJsonFamily, disposeFromStore, newest, seekInStore, IMPLICIT } from 'atom.io/internal';
 import { stringifyJson } from 'atom.io/json';
+import { getJoin } from 'atom.io/data';
 
 var Molecule = class _Molecule {
-  constructor(key, above = [], store = IMPLICIT.STORE) {
-    this.key = key;
-    this.above = above;
+  constructor(store, above, token) {
     this.store = store;
+    this.token = token;
+    this.type = `molecule`;
     this.below = [];
     this.tokens = [];
     this.joins = [];
+    this.subject = new Subject();
     this.dispose = this[Symbol.dispose];
-    store.molecules.set(stringifyJson(key), this);
-    for (const parent of above) {
-      parent.below.push(this);
+    if (above) {
+      if (Array.isArray(above)) {
+        this.above = above;
+        for (const parent of above) {
+          parent.below.push(this);
+        }
+      } else {
+        this.above = [above];
+        above.below.push(this);
+      }
+    } else {
+      this.above = [];
     }
   }
+  get key() {
+    return this.token.key;
+  }
   bond(token) {
-    const state = initFamilyMember(token, this.key, this.store);
+    const state = initFamilyMember(token, this.token.key, this.store);
     if (token.type === `mutable_atom_family`) {
       const jsonFamily = getJsonFamily(token, this.store);
-      const jsonState = initFamilyMember(jsonFamily, this.key, this.store);
+      const jsonState = initFamilyMember(jsonFamily, this.token.key, this.store);
       this.tokens.push(jsonState);
     }
     this.tokens.push(state);
+    this.subject.next({ type: `state_creation`, token: state });
     return state;
   }
   spawn(key) {
-    const child = new _Molecule(key, [this], this.store);
+    const child = new _Molecule(this.store, this, { key, type: `molecule` });
     return child;
   }
   with(molecule) {
     return (key) => {
-      const child = new _Molecule(key, [this, molecule], this.store);
+      const child = new _Molecule(this.store, [this, molecule], {
+        key,
+        type: `molecule`
+      });
       return child;
     };
   }
@@ -66,32 +83,130 @@ var Molecule = class _Molecule {
     while (this.tokens.length > 0) {
       const token = this.tokens.pop();
       if (token) {
-        disposeState(token, this.store);
+        disposeFromStore(token, this.store);
       }
     }
     while (this.joins.length > 0) {
       const join = this.joins.pop();
       if (join) {
-        join.molecules.delete(stringifyJson(this.key));
+        join.molecules.delete(stringifyJson(this.token.key));
       }
     }
   }
   join(token) {
     const join = getJoin(token, this.store);
-    join.molecules.set(stringifyJson(this.key), this);
+    join.molecules.set(stringifyJson(this.token.key), this);
     this.joins.push(join);
   }
   [Symbol.dispose]() {
     this.clear();
-    this.store.molecules.delete(stringifyJson(this.key));
+    const target = newest(this.store);
+    target.molecules.delete(stringifyJson(this.token.key));
     for (const parent of this.above) {
       parent.detach(this);
     }
   }
 };
+
+// immortal/src/make-molecule.ts
+function createMoleculeFamily(options, store) {
+  const subject = new Internal.Subject();
+  const token = {
+    key: options.key,
+    type: `molecule_family`
+  };
+  const family = Object.assign(options.new(store), __spreadProps(__spreadValues({}, token), { subject }));
+  store.moleculeFamilies.set(options.key, family);
+  return token;
+}
+function moleculeFamily(options) {
+  return createMoleculeFamily(options, Internal.IMPLICIT.STORE);
+}
+function makeMoleculeInStore(store, context, family, key, ...params) {
+  const target = Internal.newest(store);
+  const token = {
+    type: `molecule`,
+    key,
+    family
+  };
+  const contextArray = Array.isArray(context) ? context : [context];
+  const owners = contextArray.map((ctx) => store.molecules.get(stringifyJson(ctx.key))).filter((m) => m !== void 0);
+  const Formula = Internal.withdraw(family, store);
+  const molecule = new Formula(owners, token, ...params);
+  target.molecules.set(stringifyJson(key), molecule);
+  const update = {
+    type: `molecule_creation`,
+    token,
+    family,
+    context: contextArray,
+    params
+  };
+  const isTransaction = Internal.isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(update);
+  } else {
+    Formula.subject.next(update);
+  }
+  return token;
+}
+function makeMolecule(context, family, key, ...params) {
+  return makeMoleculeInStore(
+    Internal.IMPLICIT.STORE,
+    context,
+    family,
+    key,
+    ...params
+  );
+}
+function useMoleculeFromStore(token, store) {
+  const molecule = store.molecules.get(stringifyJson(token.key));
+  return molecule;
+}
+function useMolecule(token) {
+  return useMoleculeFromStore(token, Internal.IMPLICIT.STORE);
+}
+function disposeMolecule(token, store) {
+  const mole = useMoleculeFromStore(token, store);
+  if (!mole || !token.family) {
+    return;
+  }
+  const { family } = token;
+  const Formula = Internal.withdraw(family, store);
+  const disposalEvent = {
+    type: `molecule_disposal`,
+    token,
+    family,
+    context: mole.above,
+    familyKeys: mole.tokens.map((t) => {
+      var _a;
+      return (_a = t.family) == null ? void 0 : _a.key;
+    }).filter((k) => typeof k === `string`)
+  };
+  if (token.family) {
+    disposalEvent.family = token.family;
+  }
+  const isTransaction = Internal.isChildStore(store) && store.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    store.transactionMeta.update.updates.push(disposalEvent);
+  } else {
+    Formula.subject.next(disposalEvent);
+  }
+  mole.dispose();
+}
+function makeRootMolecule(key, store = Internal.IMPLICIT.STORE) {
+  const molecule = new Molecule(store, void 0, { key, type: `molecule` });
+  store.molecules.set(stringifyJson(key), molecule);
+  return {
+    key,
+    type: `molecule`
+  };
+}
 function seekState(token, key) {
+  if (token.type === `molecule_family`) {
+    return seekInStore(token, key, IMPLICIT.STORE);
+  }
   const state = seekInStore(token, key, IMPLICIT.STORE);
   return state;
 }
 
-export { Molecule, seekState };
+export { Molecule, createMoleculeFamily, disposeMolecule, makeMolecule, makeMoleculeInStore, makeRootMolecule, moleculeFamily, seekState, useMolecule, useMoleculeFromStore };

package/immortal/src/index.ts

@@ -1,2 +1,3 @@
+export * from "./make-molecule"
 export * from "./molecule"
 export * from "./seek-state"