atom.io 0.30.0 → 0.30.2

package/data/dist/index.d.ts

@@ -1,116 +1,149 @@
 import * as AtomIO from 'atom.io';
 import { ReadonlySelectorFamilyToken, MutableAtomFamilyToken, SetterToolkit, disposeState, ReadonlySelectorToken } from 'atom.io';
-import { Store, JunctionSchema, JunctionEntries, Molecule, Junction } from 'atom.io/internal';
+import { Store, JunctionSchemaBase, JunctionEntriesBase, Molecule, Junction } from 'atom.io/internal';
 import { Canonical, stringified, Json } from 'atom.io/json';
 import { findState } from 'atom.io/ephemeral';
+import { Refinement } from 'atom.io/introspection';
 import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
 declare function dict<State, Key extends Canonical>(family: AtomIO.ReadonlySelectorFamilyToken<State, Key> | AtomIO.RegularAtomFamilyToken<State, Key> | AtomIO.WritableSelectorFamilyToken<State, Key>, index: AtomIO.ReadonlySelectorToken<Key[]> | AtomIO.RegularAtomToken<Key[]> | AtomIO.WritableSelectorToken<Key[]>, store?: Store): AtomIO.ReadonlySelectorToken<{
     [K in stringified<Key>]: State;
 }>;
 
-interface JoinOptions<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> extends Json.Object, JunctionSchema<ASide, BSide>, Partial<JunctionEntries<Content>> {
+interface JoinOptions<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> extends JunctionSchemaBase<ASide, BSide>, Partial<JunctionEntriesBase<AType, BType, Content>> {
     readonly key: string;
     readonly cardinality: Cardinality;
+    readonly isAType: Refinement<string, AType>;
+    readonly isBType: Refinement<string, BType>;
 }
-type JoinStateFamilies<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
-    readonly [AB in ASide | BSide as AB extends ASide ? `${AB}EntryOf${Capitalize<BSide>}` : `${AB}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
-        string,
+type JoinStateFamilies<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
+    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[
+        AType,
+        Content
+    ] | null, BType>;
+} & {
+    readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
+        BType,
         Content
-    ] | null, string>;
+    ] | null, AType>;
 } : {}) & {
-    readonly [AB in ASide | BSide as AB extends ASide ? `${AB}KeyOf${Capitalize<BSide>}` : `${AB}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<string | null, string>;
+    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType>;
+} & {
+    readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType | null, AType>;
 } : Cardinality extends `1:n` ? (Content extends Json.Object ? {
     readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[
-        string,
+        AType,
         Content
-    ] | null, string>;
+    ] | null, BType>;
 } & {
     readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
-        string,
+        BType,
         Content
-    ][], string>;
+    ][], AType>;
 } : {}) & {
-    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<string | null, string>;
+    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType>;
 } & {
-    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<string[], string>;
+    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType>;
 } : Cardinality extends `n:n` ? (Content extends Json.Object ? {
-    readonly [AB in ASide | BSide as AB extends ASide ? `${AB}EntriesOf${Capitalize<BSide>}` : `${AB}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
-        string,
+    readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[
+        AType,
         Content
-    ][], string>;
+    ][], BType>;
+} & {
+    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[
+        BType,
+        Content
+    ][], AType>;
 } : {}) & {
-    readonly [AB in ASide | BSide as AB extends ASide ? `${AB}KeysOf${Capitalize<BSide>}` : `${AB}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<string[], string>;
+    readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType[], BType>;
+} & {
+    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType>;
 } : never;
-declare class Join<const ASide extends string, const BSide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object | null = null> {
+declare class Join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object | null = null> {
     private options;
     private defaultContent;
     private toolkit;
     retrieve: typeof findState;
     molecules: Map<string, Molecule<any>>;
-    relations: Junction<ASide, BSide, Content>;
-    states: JoinStateFamilies<ASide, BSide, Cardinality, Content>;
+    relations: Junction<ASide, AType, BSide, BType, Content>;
+    states: JoinStateFamilies<ASide, AType, BSide, BType, Cardinality, Content>;
     core: {
         findRelatedKeysState: MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
     };
     transact(toolkit: SetterToolkit & {
         dispose: typeof disposeState;
-    }, run: (join: Join<ASide, BSide, Cardinality, Content>) => void): void;
+    }, run: (join: Join<ASide, AType, BSide, BType, Cardinality, Content>) => void): void;
     store: Store;
-    alternates: Map<string, Join<ASide, BSide, Cardinality, Content>>;
+    alternates: Map<string, Join<ASide, AType, BSide, BType, Cardinality, Content>>;
     [Symbol.dispose](): void;
-    in(store: Store): Join<ASide, BSide, Cardinality, Content>;
-    constructor(options: JoinOptions<ASide, BSide, Cardinality, Content>, defaultContent: Content | undefined, store?: Store);
+    in(store: Store): Join<ASide, AType, BSide, BType, Cardinality, Content>;
+    constructor(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content | undefined, store?: Store);
 }
-type JoinToken<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null = null> = {
+type JoinToken<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null = null> = {
     key: string;
     type: `join`;
     cardinality: Cardinality;
     a: ASide;
     b: BSide;
+    __aType?: AType;
+    __bType?: BType;
     __content?: Content;
 };
-declare function join<const ASide extends string, const BSide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`>(options: JoinOptions<ASide, BSide, Cardinality, null>, defaultContent?: undefined, store?: Store): JoinToken<ASide, BSide, Cardinality, null>;
-declare function join<const ASide extends string, const BSide extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object>(options: JoinOptions<ASide, BSide, Cardinality, Content>, defaultContent: Content, store?: Store): JoinToken<ASide, BSide, Cardinality, Content>;
+declare function join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, null>, defaultContent?: undefined, store?: Store): JoinToken<ASide, AType, BSide, BType, Cardinality, null>;
+declare function join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content, store?: Store): JoinToken<ASide, AType, BSide, BType, Cardinality, Content>;
 declare function getJoinMap(store: Store & {
-    joins?: Map<string, Join<any, any, any, any>>;
-}): Map<string, Join<any, any, any, any>>;
-declare function getJoin<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, store: Store): Join<ASide, BSide, Cardinality, Content>;
-type JoinStates<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
-    readonly [AB in ASide | BSide as AB extends ASide ? `${AB}EntryOf${Capitalize<BSide>}` : `${AB}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
-        string,
+    joins?: Map<string, Join<any, any, any, any, any, any>>;
+}): Map<string, Join<any, any, any, any, any, any>>;
+declare function getJoin<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, store: Store): Join<ASide, AType, BSide, BType, Cardinality, Content>;
+type JoinStates<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
+    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<[
+        AType,
+        Content
+    ] | null, BType>;
+} & {
+    readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
+        BType,
         Content
-    ] | null>;
+    ] | null, AType>;
 } : {}) & {
-    readonly [AB in ASide | BSide as AB extends ASide ? `${AB}KeyOf${Capitalize<BSide>}` : `${AB}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken<string | null>;
+    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<AType | null, BType>;
+} & {
+    readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken<BType | null, AType>;
 } : Cardinality extends `1:n` ? (Content extends Json.Object ? {
     readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<[
-        string,
+        AType,
         Content
-    ] | null>;
+    ] | null, BType>;
 } & {
     readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
-        string,
+        BType,
         Content
-    ][]>;
+    ][], AType>;
 } : {}) & {
-    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<string | null>;
+    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<AType | null, BType>;
 } & {
-    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<string[]>;
+    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<BType[], AType>;
 } : Cardinality extends `n:n` ? (Content extends Json.Object ? {
-    readonly [AB in ASide | BSide as AB extends ASide ? `${AB}EntriesOf${Capitalize<BSide>}` : `${AB}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
-        string,
+    readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorToken<[
+        AType,
         Content
-    ][]>;
+    ][], BType>;
+} & {
+    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<[
+        BType,
+        Content
+    ][], AType>;
 } : {}) & {
-    readonly [AB in ASide | BSide as AB extends ASide ? `${AB}KeysOf${Capitalize<BSide>}` : `${AB}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<string[]>;
+    readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorToken<AType[], BType>;
+} & {
+    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<BType[], AType>;
 } : never;
-declare function findRelationsInStore<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, key: string, store: Store): JoinStates<ASide, BSide, Cardinality, Content>;
-declare function findRelations<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, key: string): JoinStates<ASide, BSide, Cardinality, Content>;
-declare function editRelationsInStore<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, change: (relations: Junction<ASide, BSide, Content>) => void, store: Store): void;
-declare function editRelations<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>, change: (relations: Junction<ASide, BSide, Content>) => void): void;
-declare function getInternalRelationsFromStore(token: JoinToken<any, any, any, any>, store: Store): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
-declare function getInternalRelations<ASide extends string, BSide extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, BSide, Cardinality, Content>): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
+declare function findRelationsInStore<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, key: AType | BType, store: Store): JoinStates<ASide, AType, BSide, BType, Cardinality, Content>;
+declare function findRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, key: AType | BType): JoinStates<ASide, AType, BSide, BType, Cardinality, Content>;
+declare function editRelationsInStore<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void, store: Store): void;
+declare function editRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void): void;
+declare function getInternalRelationsFromStore(token: JoinToken<any, any, any, any, any, any>, store: Store): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
+declare function getInternalRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string>;
 
 declare function struct<Struct extends {
     [key: string]: unknown;

package/data/dist/index.js

@@ -61,7 +61,7 @@ var Join = class _Join {
       if (maybeToken) {
         return maybeToken;
       }
-      const molecule = this.molecules.get(stringifyJson(key));
+      const molecule = this.store.molecules.get(stringifyJson(key));
       if (molecule) {
         const family = withdraw(token, store);
         return growMoleculeInStore(molecule, family, store);
@@ -231,13 +231,6 @@ var Join = class _Join {
         },
         [`join`, `content`]
       );
-      ({
-        key: options.key,
-        type: `join`,
-        a: options.between[0],
-        b: options.between[1],
-        cardinality: options.cardinality
-      });
       contentMolecules = createMoleculeFamily(store, {
         key: `${options.key}/content-molecules`,
         new: class ContentMolecule {
@@ -276,30 +269,35 @@ var Join = class _Join {
     } else {
       externalStore = baseExternalStoreConfiguration;
     }
-    const relations = new Junction(options, {
-      externalStore,
-      makeContentKey: (...args) => {
-        const sorted = args.sort();
-        const compositeKey = `${sorted[0]}:${sorted[1]}`;
-        const [m0, m1] = sorted.map(
-          (key) => this.molecules.get(stringifyJson(key))
-        );
-        if (store.config.lifespan === `immortal` && m0 && m1) {
-          const target = newest(store);
-          const moleculeToken = makeMoleculeInStore(
-            target,
-            [m0, m1],
-            contentMolecules,
-            compositeKey
-          );
-          this.molecules.set(
-            `"${compositeKey}"`,
-            withdraw(moleculeToken, target)
+    const relations = new Junction(
+      options,
+      {
+        externalStore,
+        isAType: options.isAType,
+        isBType: options.isBType,
+        makeContentKey: (...args) => {
+          const sorted = args.sort();
+          const compositeKey = `${sorted[0]}:${sorted[1]}`;
+          const [m0, m1] = sorted.map(
+            (key) => this.molecules.get(stringifyJson(key))
           );
+          if (store.config.lifespan === `immortal` && m0 && m1) {
+            const target = newest(store);
+            const moleculeToken = makeMoleculeInStore(
+              target,
+              [m0, m1],
+              contentMolecules,
+              compositeKey
+            );
+            this.molecules.set(
+              `"${compositeKey}"`,
+              withdraw(moleculeToken, target)
+            );
+          }
+          return compositeKey;
         }
-        return compositeKey;
       }
-    });
+    );
     const createSingleKeyStateFamily = () => createReadonlySelectorFamily(
       store,
       {
@@ -334,14 +332,18 @@ var Join = class _Join {
       store,
       {
         key: `${options.key}/singleRelatedEntry`,
-        get: (key) => ({ get }) => {
-          const relatedKeysState = this.retrieve(relatedKeysAtoms, key);
+        get: (x) => ({ get }) => {
+          const relatedKeysState = this.retrieve(relatedKeysAtoms, x);
           const relatedKeys = get(relatedKeysState);
-          for (const relatedKey of relatedKeys) {
-            const contentKey = relations.makeContentKey(key, relatedKey);
+          for (const y of relatedKeys) {
+            let a = relations.isAType?.(x) ? x : void 0;
+            let b = a === void 0 ? x : void 0;
+            a ??= y;
+            b ??= y;
+            const contentKey = relations.makeContentKey(a, b);
             const contentState = this.retrieve(contentAtoms, contentKey);
             const content = get(contentState);
-            return [relatedKey, content];
+            return [y, content];
           }
           return null;
         }
@@ -352,15 +354,19 @@ var Join = class _Join {
       store,
       {
         key: `${options.key}/multipleRelatedEntries`,
-        get: (key) => ({ get }) => {
+        get: (x) => ({ get }) => {
           const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
-          const jsonState = this.retrieve(jsonFamily, key);
+          const jsonState = this.retrieve(jsonFamily, x);
           const json = get(jsonState);
-          return json.members.map((relatedKey) => {
-            const contentKey = relations.makeContentKey(key, relatedKey);
+          return json.members.map((y) => {
+            let a = relations.isAType?.(x) ? x : void 0;
+            let b = a === void 0 ? x : void 0;
+            a ??= y;
+            b ??= y;
+            const contentKey = relations.makeContentKey(a, b);
             const contentState = this.retrieve(contentAtoms, contentKey);
             const content = get(contentState);
-            return [relatedKey, content];
+            return [y, content];
           });
         }
       },