atom.io 0.18.3 → 0.19.1

package/data/src/join.ts

@@ -1,8 +1,11 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import type {
 	MutableAtomFamily,
+	MutableAtomFamilyToken,
+	MutableAtomToken,
 	Read,
 	ReadonlySelectorFamily,
+	ReadonlySelectorToken,
 	RegularAtomFamily,
 	Transactors,
 	Write,
@@ -17,6 +20,8 @@ import {
 	findInStore,
 	getFromStore,
 	getJsonFamily,
+	isChildStore,
+	newest,
 	setIntoStore,
 } from "atom.io/internal"
 import type { Json } from "atom.io/json"
@@ -54,7 +59,7 @@ export interface JoinOptions<
 	readonly cardinality: Cardinality
 }
 
-export type JoinState<
+export type JoinStateFamilies<
 	ASide extends string,
 	BSide extends string,
 	Cardinality extends Rel8.Cardinality,
@@ -68,7 +73,7 @@ export type JoinState<
 						[string, Content] | null,
 						string
 					>
-			  }
+				}
 			: {}) & {
 			readonly [AB in ASide | BSide as AB extends ASide
 				? `${AB}KeyOf${Capitalize<BSide>}`
@@ -76,33 +81,33 @@ export type JoinState<
 				string | null,
 				string
 			>
-	  }
+		}
 	: Cardinality extends `1:n`
-	  ? (Content extends Json.Object
+		? (Content extends Json.Object
 				? {
 						readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamily<
 							[string, Content] | null,
 							string
 						>
-				  } & {
+					} & {
 						readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamily<
 							[string, Content][],
 							string
 						>
-				  }
+					}
 				: {}) & {
 				readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamily<
 					string | null,
 					string
 				>
-		  } & {
+			} & {
 				readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamily<
 					string[],
 					string
 				>
-		  }
-	  : Cardinality extends `n:n`
-		  ? (Content extends Json.Object
+			}
+		: Cardinality extends `n:n`
+			? (Content extends Json.Object
 					? {
 							readonly [AB in ASide | BSide as AB extends ASide
 								? `${AB}EntriesOf${Capitalize<BSide>}`
@@ -110,7 +115,7 @@ export type JoinState<
 								[string, Content][],
 								string
 							>
-					  }
+						}
 					: {}) & {
 					readonly [AB in ASide | BSide as AB extends ASide
 						? `${AB}KeysOf${Capitalize<BSide>}`
@@ -118,8 +123,8 @@ export type JoinState<
 						string[],
 						string
 					>
-			  }
-		  : never
+				}
+			: never
 
 export class Join<
 	const ASide extends string,
@@ -131,7 +136,7 @@ export class Join<
 	private defaultContent: Content | undefined
 	private transactors: Transactors
 	public relations: Junction<ASide, BSide, Content>
-	public states: JoinState<ASide, BSide, Cardinality, Content>
+	public states: JoinStateFamilies<ASide, BSide, Cardinality, Content>
 	public core: {
 		findRelatedKeysState: MutableAtomFamily<
 			SetRTX<string>,
@@ -435,8 +440,8 @@ export class Join<
 				const baseStates = {
 					[stateKeyA]: findSingleRelatedKeyState,
 					[stateKeyB]: findSingleRelatedKeyState,
-				} as JoinState<ASide, BSide, Cardinality, Content>
-				let states: JoinState<ASide, BSide, Cardinality, Content>
+				} as JoinStateFamilies<ASide, BSide, Cardinality, Content>
+				let states: JoinStateFamilies<ASide, BSide, Cardinality, Content>
 				if (defaultContent) {
 					const findSingleRelatedEntryState = createSingleEntryStateFamily()
 					const entriesStateKeyA = `${a}EntryOf${capitalize(b)}` as const
@@ -461,8 +466,8 @@ export class Join<
 				const baseStates = {
 					[stateKeyA]: findSingleRelatedKeyState,
 					[stateKeyB]: findMultipleRelatedKeysState,
-				} as JoinState<ASide, BSide, Cardinality, Content>
-				let states: JoinState<ASide, BSide, Cardinality, Content>
+				} as JoinStateFamilies<ASide, BSide, Cardinality, Content>
+				let states: JoinStateFamilies<ASide, BSide, Cardinality, Content>
 				if (defaultContent) {
 					const findSingleRelatedEntryState = createSingleEntryStateFamily()
 					const findMultipleRelatedEntriesState = getMultipleEntryStateFamily()
@@ -487,8 +492,8 @@ export class Join<
 				const baseStates = {
 					[stateKeyA]: findMultipleRelatedKeysState,
 					[stateKeyB]: findMultipleRelatedKeysState,
-				} as JoinState<ASide, BSide, Cardinality, Content>
-				let states: JoinState<ASide, BSide, Cardinality, Content>
+				} as JoinStateFamilies<ASide, BSide, Cardinality, Content>
+				let states: JoinStateFamilies<ASide, BSide, Cardinality, Content>
 				if (defaultContent) {
 					const findMultipleRelatedEntriesState = getMultipleEntryStateFamily()
 					const entriesStateKeyA = `${a}EntriesOf${capitalize(b)}` as const
@@ -508,6 +513,20 @@ export class Join<
 	}
 }
 
+export type JoinToken<
+	ASide extends string,
+	BSide 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
+	__content?: Content
+}
+
 export function join<
 	const ASide extends string,
 	const BSide extends string,
@@ -516,22 +535,7 @@ export function join<
 	options: JoinOptions<ASide, BSide, Cardinality, null>,
 	defaultContent?: undefined,
 	store?: Store,
-): {
-	readonly relations: Junction<ASide, BSide, null>
-	readonly states: JoinState<ASide, BSide, Cardinality, null>
-	readonly in: (store: Store) => Join<ASide, BSide, Cardinality>
-	readonly transact: (
-		transactors: Transactors,
-		run: (join: Join<ASide, BSide, Cardinality, null>) => void,
-	) => void
-	readonly core: {
-		readonly findRelatedKeysState: MutableAtomFamily<
-			SetRTX<string>,
-			SetRTXJson<string>,
-			string
-		>
-	}
-}
+): JoinToken<ASide, BSide, Cardinality, null>
 export function join<
 	const ASide extends string,
 	const BSide extends string,
@@ -541,22 +545,7 @@ export function join<
 	options: JoinOptions<ASide, BSide, Cardinality, Content>,
 	defaultContent: Content,
 	store?: Store,
-): {
-	readonly relations: Junction<ASide, BSide, Content>
-	readonly states: JoinState<ASide, BSide, Cardinality, Content>
-	readonly in: (store: Store) => Join<ASide, BSide, Cardinality, Content>
-	readonly transact: (
-		transactors: Transactors,
-		run: (join: Join<ASide, BSide, Cardinality, Content>) => void,
-	) => void
-	readonly core: {
-		readonly findRelatedKeysState: MutableAtomFamily<
-			SetRTX<string>,
-			SetRTXJson<string>,
-			string
-		>
-	}
-}
+): JoinToken<ASide, BSide, Cardinality, Content>
 export function join<
 	ASide extends string,
 	BSide extends string,
@@ -566,6 +555,285 @@ export function join<
 	options: JoinOptions<ASide, BSide, Cardinality, Content>,
 	defaultContent: Content | undefined,
 	store: Store = IMPLICIT.STORE,
+): JoinToken<ASide, BSide, Cardinality, Content> {
+	const joins = getJoinMap(store)
+	joins.set(options.key, new Join(options, defaultContent, store))
+	const token: JoinToken<ASide, BSide, Cardinality, Content> = {
+		key: options.key,
+		type: `join`,
+		a: options.between[0],
+		b: options.between[1],
+		cardinality: options.cardinality,
+	}
+	return token
+}
+
+export function getJoinMap(
+	store: Store & { joins?: Map<string, Join<any, any, any, any>> },
+): Map<string, Join<any, any, any, any>> {
+	if (`joins` in store && store.joins instanceof Map) {
+		return store.joins
+	}
+	const joins = new Map<string, Join<any, any, any, any>>()
+	store.joins = joins
+	return joins
+}
+export 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> {
-	return new Join(options, defaultContent, store)
+	const joinMap = getJoinMap(store)
+	let join = joinMap.get(token.key)
+	if (join === undefined) {
+		const rootJoinMap = getJoinMap(IMPLICIT.STORE)
+		join = rootJoinMap.get(token.key)?.in(store)
+		if (join === undefined) {
+			throw new Error(
+				`Join "${token.key}" not found in store "${store.config.name}"`,
+			)
+		}
+		joinMap.set(token.key, join)
+	}
+	return join
+}
+
+export type JoinStates<
+	ASide extends string,
+	BSide extends string,
+	Cardinality extends Rel8.Cardinality,
+	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, Content] | null
+					>
+				}
+			: {}) & {
+			readonly [AB in ASide | BSide as AB extends ASide
+				? `${AB}KeyOf${Capitalize<BSide>}`
+				: `${AB}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken<string | null>
+		}
+	: Cardinality extends `1:n`
+		? (Content extends Json.Object
+				? {
+						readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+							[string, Content] | null
+						>
+					} & {
+						readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+							[string, Content][]
+						>
+					}
+				: {}) & {
+				readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken<
+					string | null
+				>
+			} & {
+				readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<
+					string[]
+				>
+			}
+		: 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, Content][]
+							>
+						}
+					: {}) & {
+					readonly [AB in ASide | BSide as AB extends ASide
+						? `${AB}KeysOf${Capitalize<BSide>}`
+						: `${AB}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken<string[]>
+				}
+			: never
+
+export 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> {
+	const join = getJoin(token, store)
+	let relations: JoinStates<ASide, BSide, Cardinality, Content>
+	switch (token.cardinality satisfies `1:1` | `1:n` | `n:n`) {
+		case `1:1`: {
+			const keyAB = `${token.a}KeyOf${capitalize(token.b)}`
+			const keyBA = `${token.b}KeyOf${capitalize(token.a)}`
+			relations = {
+				get [keyAB]() {
+					const familyAB = join.states[keyAB as any]
+					const state = findInStore(familyAB, key, store)
+					return state
+				},
+				get [keyBA]() {
+					const familyBA = join.states[keyBA as any]
+					const state = findInStore(familyBA, key, store)
+					return state
+				},
+			} as JoinStates<ASide, BSide, Cardinality, Content>
+			const entryAB = `${token.a}EntryOf${capitalize(token.b)}`
+			if (entryAB in join.states) {
+				const entryBA = `${token.b}EntryOf${capitalize(token.a)}`
+				Object.assign(relations, {
+					get [entryAB]() {
+						const familyAB = join.states[entryAB as any]
+						const state = findInStore(familyAB, key, store)
+						return state
+					},
+					get [entryBA]() {
+						const familyBA = join.states[entryBA as any]
+						const state = findInStore(familyBA, key, store)
+						return state
+					},
+				})
+			}
+			break
+		}
+		case `1:n`: {
+			const keyAB = `${token.a}KeyOf${capitalize(token.b)}`
+			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`
+			relations = {
+				get [keyAB]() {
+					const familyAB = join.states[keyAB as any]
+					const state = findInStore(familyAB, key, store)
+					return state
+				},
+				get [keysBA]() {
+					const familyBA = join.states[keysBA as any]
+					const state = findInStore(familyBA, key, store)
+					return state
+				},
+			} as JoinStates<ASide, BSide, Cardinality, Content>
+			const entryAB = `${token.a}EntryOf${capitalize(token.b)}`
+			if (entryAB in join.states) {
+				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`
+				Object.assign(relations, {
+					get [entryAB]() {
+						const familyAB = join.states[entryAB as any]
+						const state = findInStore(familyAB, key, store)
+						return state
+					},
+					get [entriesBA]() {
+						const familyBA = join.states[entriesBA as any]
+						const state = findInStore(familyBA, key, store)
+						return state
+					},
+				})
+			}
+			break
+		}
+		case `n:n`: {
+			const keysAB = `${token.a}KeysOf${capitalize(token.b)}`
+			const keysBA = `${token.b}KeysOf${capitalize(token.a)}`
+			relations = {
+				get [keysAB]() {
+					const familyAB = join.states[keysAB as any]
+					const state = findInStore(familyAB, key, store)
+					return state
+				},
+				get [keysBA]() {
+					const familyBA = join.states[keysBA as any]
+					const state = findInStore(familyBA, key, store)
+					return state
+				},
+			} as JoinStates<ASide, BSide, Cardinality, Content>
+			const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`
+			if (entriesAB in join.states) {
+				const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`
+				Object.assign(relations, {
+					get [entriesAB]() {
+						const familyAB = join.states[entriesAB as any]
+						const state = findInStore(familyAB, key, store)
+						return state
+					},
+					get [entriesBA]() {
+						const familyBA = join.states[entriesBA as any]
+						const state = findInStore(familyBA, key, store)
+						return state
+					},
+				})
+			}
+		}
+	}
+	return relations
+}
+
+export 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> {
+	return findRelationsInStore(token, key, IMPLICIT.STORE)
+}
+
+export 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 {
+	const join = getJoin(token, store)
+	const target = newest(store)
+	if (isChildStore(target)) {
+		const { transactors } = target.transactionMeta
+		join.transact(transactors, ({ relations }) => {
+			change(relations)
+		})
+	} else {
+		change(join.relations)
+	}
+}
+
+export 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 {
+	editRelationsInStore(token, change, IMPLICIT.STORE)
+}
+
+export function getInternalRelationsFromStore(
+	token: JoinToken<any, any, any, any>,
+	store: Store,
+): MutableAtomFamilyToken<SetRTX<string>, SetRTXJson<string>, string> {
+	const join = getJoin(token, store)
+	const family = join.core.findRelatedKeysState
+	return family
+}
+
+export 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> {
+	return getInternalRelationsFromStore(token, IMPLICIT.STORE)
 }

package/dist/{chunk-CVBEVTM5.js → chunk-7VCCW45K.js}

@@ -34,18 +34,6 @@ var doNothing = () => void 0;
 var become = (nextVersionOfThing) => (originalThing) => nextVersionOfThing instanceof Function ? nextVersionOfThing(
   originalThing instanceof Function ? originalThing() : originalThing
 ) : nextVersionOfThing;
-var isModifier = (validate) => (sample) => {
-  const sampleIsValid = validate(sample);
-  if (!sampleIsValid) {
-    throw new Error(`Invalid test case: JSON.stringify(${sample})`);
-  }
-  return (input) => {
-    if (typeof input !== `function`)
-      return false;
-    const testResult = input(sample);
-    return validate(testResult);
-  };
-};
 var pass = (...params) => (fn) => fn(...params);
 var raiseError = (message) => {
   throw new Error(message);
@@ -58,24 +46,11 @@ var fallback = (fn, fallbackValue) => {
   }
 };
 
-// ../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/nullish/index.ts
 var isUndefined = (input) => input === void 0;
@@ -103,7 +78,6 @@ var mob = (fn) => (obj) => mapObject(obj, fn);
 // ../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(
@@ -132,8 +106,6 @@ var hasProperties = (isValue, options = { allowExtraProperties: false }) => {
 };
 var ALLOW_EXTENSION = { allowExtraProperties: true };
 var doesExtend = (isValue) => hasProperties(isValue, ALLOW_EXTENSION);
-var DO_NOT_ALLOW_EXTENSION = { allowExtraProperties: false };
-var hasExactProperties = (isValue) => hasProperties(isValue, DO_NOT_ALLOW_EXTENSION);
 
 // ../anvl/src/object/sprawl.ts
 var sprawl = (tree, inspector) => {
@@ -161,19 +133,9 @@ var sprawl = (tree, inspector) => {
 };
 
 // ../anvl/src/object/index.ts
-var treeShake = (shouldDiscard = isUndefined) => (obj) => {
-  const newObj = {};
-  const entries = Object.entries(obj);
-  for (const [key, val] of entries) {
-    if (!shouldDiscard(val, key)) {
-      newObj[key] = val;
-    }
-  }
-  return newObj;
-};
 var delve = (obj, path) => {
   const found = path.reduce((acc, key) => acc == null ? void 0 : acc[key], obj);
   return found === void 0 ? new Error(`Not found`) : { found };
 };
 
-export { addTo, become, comprises, delve, doNothing, doesExtend, entriesToRecord, fallback, hasExactProperties, ifDefined, isArray, isEmptyArray, isEmptyObject, isModifier, isOneOf, isPlainObject, isRecord, map, mapObject, pipe, raiseError, recordToEntries, sprawl, treeShake };
+export { become, delve, doNothing, doesExtend, fallback, ifDefined, isArray, isPlainObject, isRecord, mapObject, pipe, raiseError, recordToEntries, sprawl };