atom.io 0.31.0 → 0.31.1

package/dist/chunk-ICGFFQ3H.js

@@ -1,272 +0,0 @@
-import { IMPLICIT, newest, isChildStore, findInStore, disposeFromStore, getTrace } from 'atom.io/internal';
-import { stringifyJson, parseJson } from 'atom.io/json';
-
-// src/molecule.ts
-function makeRootMoleculeInStore(key, store = IMPLICIT.STORE) {
-  const molecule = {
-    key,
-    stringKey: stringifyJson(key),
-    dependsOn: `any`
-  };
-  store.molecules.set(stringifyJson(key), molecule);
-  return key;
-}
-var $claim = Symbol(`claim`);
-function allocateIntoStore(store, provenance, key, dependsOn = `any`) {
-  const origin = provenance;
-  const stringKey = stringifyJson(key);
-  const invalidKeys = [];
-  const target = newest(store);
-  if (Array.isArray(origin)) {
-    for (const formerClaim of origin) {
-      const claimString = stringifyJson(formerClaim);
-      const claim = target.molecules.get(claimString);
-      if (claim) {
-        store.moleculeGraph.set(claimString, stringKey, { source: claimString });
-      } else {
-        invalidKeys.push(claimString);
-      }
-    }
-  } else {
-    const claimString = stringifyJson(origin);
-    const claim = target.molecules.get(claimString);
-    if (claim) {
-      store.moleculeGraph.set(claimString, stringKey, { source: claimString });
-    } else {
-      invalidKeys.push(claimString);
-    }
-  }
-  if (invalidKeys.length === 0) {
-    target.molecules.set(stringKey, { key, stringKey, dependsOn });
-  }
-  const creationEvent = {
-    type: `molecule_creation`,
-    key,
-    provenance: origin
-  };
-  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(creationEvent);
-  } else {
-    target.on.moleculeCreation.next(creationEvent);
-  }
-  for (const claim of invalidKeys) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === claim
-    );
-    store.logger.error(
-      `\u274C`,
-      `molecule`,
-      key,
-      `allocation failed:`,
-      `Could not allocate to ${claim} in store "${store.config.name}".`,
-      disposal ? `
-   ${claim} was most recently disposed
-${disposal.trace}` : `No previous disposal trace for ${claim} was found.`
-    );
-  }
-  return key;
-}
-function fuseWithinStore(store, type, sideA, sideB) {
-  const compoundKey = `T$--${type}==${sideA}++${sideB}`;
-  const above = [sideA, sideB];
-  allocateIntoStore(
-    store,
-    above,
-    compoundKey,
-    `all`
-  );
-  return compoundKey;
-}
-function deallocateFromStore(store, claim) {
-  const stringKey = stringifyJson(claim);
-  const molecule = store.molecules.get(stringKey);
-  if (!molecule) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === stringKey
-    );
-    store.logger.error(
-      `\u274C`,
-      `molecule`,
-      claim,
-      `deallocation failed:`,
-      `Could not find allocation for ${stringKey} in store "${store.config.name}".`,
-      disposal ? `
-   This state was most recently deallocated
-${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`
-    );
-    return;
-  }
-  const joinKeys = store.moleculeJoins.getRelatedKeys(
-    molecule.key
-  );
-  if (joinKeys) {
-    for (const joinKey of joinKeys) {
-      const join = store.joins.get(joinKey);
-      if (join) {
-        join.relations.delete(molecule.key);
-        join.molecules.delete(molecule.stringKey);
-      }
-    }
-  }
-  store.moleculeJoins.delete(molecule.stringKey);
-  const provenance = [];
-  const values = [];
-  const disposalEvent = {
-    type: `molecule_disposal`,
-    key: molecule.key,
-    values,
-    provenance
-  };
-  const target = newest(store);
-  target.molecules.delete(stringKey);
-  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(disposalEvent);
-  }
-  const relatedMolecules = store.moleculeGraph.getRelationEntries({
-    downstreamMoleculeKey: molecule.stringKey
-  });
-  if (relatedMolecules) {
-    for (const [relatedStringKey, { source }] of relatedMolecules) {
-      if (source === molecule.stringKey) {
-        const relatedKey = parseJson(relatedStringKey);
-        deallocateFromStore(store, relatedKey);
-      } else {
-        provenance.push(source);
-      }
-    }
-  }
-  const familyKeys = target.moleculeData.getRelatedKeys(molecule.stringKey);
-  if (familyKeys) {
-    for (const familyKey of familyKeys) {
-      const family = target.families.get(familyKey);
-      const token = findInStore(store, family, molecule.key);
-      values.push([family.key, token]);
-      disposeFromStore(store, token);
-    }
-  }
-  target.moleculeGraph.delete(molecule.stringKey);
-  target.moleculeJoins.delete(molecule.stringKey);
-  target.moleculeData.delete(molecule.stringKey);
-  if (!isTransaction) {
-    target.on.moleculeDisposal.next(disposalEvent);
-  }
-  target.molecules.delete(molecule.stringKey);
-  const trace = getTrace(new Error());
-  store.disposalTraces.add({ key: stringKey, trace });
-}
-function claimWithinStore(store, newProvenance, claim, exclusive) {
-  const stringKey = stringifyJson(claim);
-  const target = newest(store);
-  const molecule = target.molecules.get(stringKey);
-  if (!molecule) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === stringKey
-    );
-    store.logger.error(
-      `\u274C`,
-      `molecule`,
-      claim,
-      `claim failed:`,
-      `Could not allocate to ${stringKey} in store "${store.config.name}".`,
-      disposal ? `
-   ${stringKey} was most recently disposed
-${disposal.trace}` : `No previous disposal trace for ${stringKey} was found.`
-    );
-    return claim;
-  }
-  const newProvenanceKey = stringifyJson(newProvenance);
-  const newProvenanceMolecule = target.molecules.get(newProvenanceKey);
-  if (!newProvenanceMolecule) {
-    const disposal = store.disposalTraces.buffer.find(
-      (item) => item?.key === newProvenanceKey
-    );
-    store.logger.error(
-      `\u274C`,
-      `molecule`,
-      claim,
-      `claim failed:`,
-      `Could not allocate to ${newProvenanceKey} in store "${store.config.name}".`,
-      disposal ? `
-   ${newProvenanceKey} was most recently disposed
-${disposal.trace}` : `No previous disposal trace for ${newProvenanceKey} was found.`
-    );
-    return claim;
-  }
-  const priorProvenance = store.moleculeGraph.getRelationEntries({
-    downstreamMoleculeKey: molecule.stringKey
-  }).filter(([, { source }]) => source !== stringKey).map(([key]) => parseJson(key));
-  if (exclusive) {
-    target.moleculeGraph.delete(stringKey);
-  }
-  target.moleculeGraph.set(
-    {
-      upstreamMoleculeKey: newProvenanceMolecule.stringKey,
-      downstreamMoleculeKey: molecule.stringKey
-    },
-    {
-      source: newProvenanceMolecule.stringKey
-    }
-  );
-  const transferEvent = {
-    type: `molecule_transfer`,
-    key: molecule.key,
-    from: priorProvenance,
-    to: [newProvenanceMolecule.key]
-  };
-  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(transferEvent);
-  }
-  return claim;
-}
-var Realm = class {
-  store;
-  constructor(store = IMPLICIT.STORE) {
-    this.store = store;
-    makeRootMoleculeInStore(`root`, store);
-  }
-  allocate(provenance, key, attachmentStyle) {
-    return allocateIntoStore(
-      this.store,
-      provenance,
-      key,
-      attachmentStyle
-    );
-  }
-  fuse(type, reagentA, reagentB) {
-    return fuseWithinStore(this.store, type, reagentA, reagentB);
-  }
-  deallocate(claim) {
-    deallocateFromStore(this.store, claim);
-  }
-  claim(newProvenance, claim, exclusive) {
-    return claimWithinStore(this.store, newProvenance, claim, exclusive);
-  }
-};
-var T$ = `T$`;
-var Anarchy = class {
-  store;
-  realm;
-  constructor(store = IMPLICIT.STORE) {
-    this.store = store;
-    this.realm = new Realm(store);
-  }
-  allocate(provenance, key, attachmentStyle) {
-    allocateIntoStore(
-      this.store,
-      provenance,
-      key,
-      attachmentStyle
-    );
-  }
-  deallocate(key) {
-    deallocateFromStore(this.store, key);
-  }
-  claim(newProvenance, key, exclusive) {
-    claimWithinStore(this.store, newProvenance, key, exclusive);
-  }
-};
-
-export { $claim, Anarchy, Realm, T$, allocateIntoStore, claimWithinStore, deallocateFromStore, fuseWithinStore, makeRootMoleculeInStore };

package/src/allocate.ts

@@ -1,443 +0,0 @@
-import type { Each, Store } from "atom.io/internal"
-import {
-	disposeFromStore,
-	findInStore,
-	getTrace,
-	IMPLICIT,
-	isChildStore,
-	newest,
-} from "atom.io/internal"
-import type { Canonical, stringified } from "atom.io/json"
-import { parseJson, stringifyJson } from "atom.io/json"
-
-import { makeRootMoleculeInStore } from "./molecule"
-import type {
-	MoleculeCreation,
-	MoleculeDisposal,
-	MoleculeTransfer,
-} from "./transaction"
-
-export const $claim = Symbol(`claim`)
-export type Claim<K extends Canonical> = K & { [$claim]?: true }
-
-export function allocateIntoStore<
-	H extends Hierarchy,
-	V extends Vassal<H>,
-	A extends Above<V, H>,
->(
-	store: Store,
-	provenance: A,
-	key: V,
-	dependsOn: `all` | `any` = `any`,
-): Claim<V> {
-	const origin = provenance as Canonical | [Canonical, Canonical]
-	const stringKey = stringifyJson(key)
-	const invalidKeys: stringified<Canonical>[] = []
-	const target = newest(store)
-
-	if (Array.isArray(origin)) {
-		for (const formerClaim of origin) {
-			const claimString = stringifyJson(formerClaim)
-			const claim = target.molecules.get(claimString)
-			if (claim) {
-				store.moleculeGraph.set(claimString, stringKey, { source: claimString })
-			} else {
-				invalidKeys.push(claimString)
-			}
-		}
-	} else {
-		const claimString = stringifyJson(origin)
-		const claim = target.molecules.get(claimString)
-		if (claim) {
-			store.moleculeGraph.set(claimString, stringKey, { source: claimString })
-		} else {
-			invalidKeys.push(claimString)
-		}
-	}
-	if (invalidKeys.length === 0) {
-		target.molecules.set(stringKey, { key, stringKey, dependsOn })
-	}
-
-	const creationEvent: MoleculeCreation = {
-		type: `molecule_creation`,
-		key,
-		provenance: origin,
-	}
-	const isTransaction =
-		isChildStore(target) && target.transactionMeta.phase === `building`
-	if (isTransaction) {
-		target.transactionMeta.update.updates.push(creationEvent)
-	} else {
-		target.on.moleculeCreation.next(creationEvent)
-	}
-
-	for (const claim of invalidKeys) {
-		const disposal = store.disposalTraces.buffer.find(
-			(item) => item?.key === claim,
-		)
-		store.logger.error(
-			`❌`,
-			`molecule`,
-			key,
-			`allocation failed:`,
-			`Could not allocate to ${claim} in store "${store.config.name}".`,
-			disposal
-				? `\n   ${claim} was most recently disposed\n${disposal.trace}`
-				: `No previous disposal trace for ${claim} was found.`,
-		)
-	}
-
-	return key as Claim<V>
-}
-
-export function fuseWithinStore<
-	H extends Hierarchy,
-	C extends CompoundFrom<H>,
-	T extends C extends CompoundTypedKey<infer t, any, any> ? t : never,
-	A extends C extends CompoundTypedKey<any, infer a, any> ? a : never,
-	B extends C extends CompoundTypedKey<any, any, infer b> ? b : never,
->(
-	store: Store,
-	type: T,
-	sideA: SingularTypedKey<A>,
-	sideB: SingularTypedKey<B>,
-): Claim<CompoundTypedKey<T, A, B>> {
-	const compoundKey: CompoundTypedKey<T, A, B> =
-		`T$--${type}==${sideA}++${sideB}`
-	const above = [sideA, sideB] as Above<Vassal<H>, H>
-	allocateIntoStore<H, Vassal<H>, Above<Vassal<H>, H>>(
-		store,
-		above,
-		compoundKey as Vassal<H>,
-		`all`,
-	)
-	return compoundKey
-}
-
-export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
-	store: Store,
-	claim: Claim<V>,
-): void {
-	const stringKey = stringifyJson(claim)
-
-	const molecule = store.molecules.get(stringKey)
-	if (!molecule) {
-		const disposal = store.disposalTraces.buffer.find(
-			(item) => item?.key === stringKey,
-		)
-		store.logger.error(
-			`❌`,
-			`molecule`,
-			claim,
-			`deallocation failed:`,
-			`Could not find allocation for ${stringKey} in store "${store.config.name}".`,
-			disposal
-				? `\n   This state was most recently deallocated\n${disposal.trace}`
-				: `No previous disposal trace for ${stringKey} was found.`,
-		)
-		return
-	}
-
-	const joinKeys = store.moleculeJoins.getRelatedKeys(
-		molecule.key as string /* 💥 RECONCILE */,
-	)
-	if (joinKeys) {
-		for (const joinKey of joinKeys) {
-			const join = store.joins.get(joinKey)
-			if (join) {
-				join.relations.delete(molecule.key)
-				join.molecules.delete(molecule.stringKey) // get rid of
-			}
-		}
-	}
-	store.moleculeJoins.delete(molecule.stringKey)
-
-	const provenance: stringified<Canonical>[] = []
-
-	const values: [string, any][] = []
-	const disposalEvent: MoleculeDisposal = {
-		type: `molecule_disposal`,
-		key: molecule.key,
-		values,
-		provenance,
-	}
-	const target = newest(store)
-	target.molecules.delete(stringKey)
-	const isTransaction =
-		isChildStore(target) && target.transactionMeta.phase === `building`
-	if (isTransaction) {
-		target.transactionMeta.update.updates.push(disposalEvent)
-	}
-	const relatedMolecules = store.moleculeGraph.getRelationEntries({
-		downstreamMoleculeKey: molecule.stringKey,
-	})
-	if (relatedMolecules) {
-		for (const [relatedStringKey, { source }] of relatedMolecules) {
-			if (source === molecule.stringKey) {
-				const relatedKey = parseJson(relatedStringKey)
-				deallocateFromStore<any, any>(store, relatedKey)
-			} else {
-				provenance.push(source)
-			}
-		}
-	}
-	const familyKeys = target.moleculeData.getRelatedKeys(molecule.stringKey)
-	if (familyKeys) {
-		for (const familyKey of familyKeys) {
-			// biome-ignore lint/style/noNonNullAssertion: tokens of molecules must have a family
-			const family = target.families.get(familyKey)!
-			const token = findInStore(store, family, molecule.key)
-			values.push([family.key, token])
-			disposeFromStore(store, token)
-		}
-	}
-
-	target.moleculeGraph.delete(molecule.stringKey)
-	target.moleculeJoins.delete(molecule.stringKey)
-	target.moleculeData.delete(molecule.stringKey)
-
-	if (!isTransaction) {
-		target.on.moleculeDisposal.next(disposalEvent)
-	}
-	target.molecules.delete(molecule.stringKey)
-
-	const trace = getTrace(new Error())
-	store.disposalTraces.add({ key: stringKey, trace })
-}
-export function claimWithinStore<
-	H extends Hierarchy,
-	V extends Exclude<Vassal<H>, CompoundTypedKey>,
-	A extends Above<V, H>,
->(
-	store: Store,
-	newProvenance: A,
-	claim: Claim<V>,
-	exclusive?: `exclusive`,
-): Claim<V> {
-	const stringKey = stringifyJson(claim)
-	const target = newest(store)
-	const molecule = target.molecules.get(stringKey)
-	if (!molecule) {
-		const disposal = store.disposalTraces.buffer.find(
-			(item) => item?.key === stringKey,
-		)
-		store.logger.error(
-			`❌`,
-			`molecule`,
-			claim,
-			`claim failed:`,
-			`Could not allocate to ${stringKey} in store "${store.config.name}".`,
-			disposal
-				? `\n   ${stringKey} was most recently disposed\n${disposal.trace}`
-				: `No previous disposal trace for ${stringKey} was found.`,
-		)
-		return claim
-	}
-
-	const newProvenanceKey = stringifyJson(newProvenance as Canonical)
-	const newProvenanceMolecule = target.molecules.get(newProvenanceKey)
-	if (!newProvenanceMolecule) {
-		const disposal = store.disposalTraces.buffer.find(
-			(item) => item?.key === newProvenanceKey,
-		)
-		store.logger.error(
-			`❌`,
-			`molecule`,
-			claim,
-			`claim failed:`,
-			`Could not allocate to ${newProvenanceKey} in store "${store.config.name}".`,
-			disposal
-				? `\n   ${newProvenanceKey} was most recently disposed\n${disposal.trace}`
-				: `No previous disposal trace for ${newProvenanceKey} was found.`,
-		)
-		return claim
-	}
-
-	const priorProvenance = store.moleculeGraph
-		.getRelationEntries({
-			downstreamMoleculeKey: molecule.stringKey,
-		})
-		.filter(([, { source }]) => source !== stringKey)
-		.map(([key]) => parseJson(key))
-	if (exclusive) {
-		target.moleculeGraph.delete(stringKey)
-	}
-	target.moleculeGraph.set(
-		{
-			upstreamMoleculeKey: newProvenanceMolecule.stringKey,
-			downstreamMoleculeKey: molecule.stringKey,
-		},
-		{
-			source: newProvenanceMolecule.stringKey,
-		},
-	)
-	const transferEvent: MoleculeTransfer = {
-		type: `molecule_transfer`,
-		key: molecule.key,
-		from: priorProvenance,
-		to: [newProvenanceMolecule.key],
-	}
-	const isTransaction =
-		isChildStore(target) && target.transactionMeta.phase === `building`
-	if (isTransaction) {
-		target.transactionMeta.update.updates.push(transferEvent)
-	}
-
-	return claim
-}
-
-export class Realm<H extends Hierarchy> {
-	public store: Store
-	public constructor(store: Store = IMPLICIT.STORE) {
-		this.store = store
-		makeRootMoleculeInStore(`root`, store)
-	}
-	public allocate<V extends Vassal<H>, A extends Above<V, H>>(
-		provenance: A,
-		key: V,
-		attachmentStyle?: `all` | `any`,
-	): Claim<V> {
-		return allocateIntoStore<H, V, A>(
-			this.store,
-			provenance,
-			key,
-			attachmentStyle,
-		)
-	}
-	public fuse<
-		C extends CompoundFrom<H>,
-		T extends C extends CompoundTypedKey<infer t, any, any> ? t : never,
-		A extends C extends CompoundTypedKey<any, infer v, any> ? v : never,
-		B extends C extends CompoundTypedKey<any, any, infer m> ? m : never,
-	>(
-		type: T,
-		reagentA: SingularTypedKey<A>,
-		reagentB: SingularTypedKey<B>,
-	): Claim<CompoundTypedKey<T, A, B>> {
-		return fuseWithinStore<H, C, T, A, B>(this.store, type, reagentA, reagentB)
-	}
-
-	public deallocate<V extends Vassal<H>>(claim: Claim<V>): void {
-		deallocateFromStore<H, V>(this.store, claim)
-	}
-	public claim<
-		V extends Exclude<Vassal<H>, CompoundTypedKey>,
-		A extends Above<V, H>,
-	>(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`): Claim<V> {
-		return claimWithinStore<H, V, A>(this.store, newProvenance, claim, exclusive)
-	}
-}
-
-export const T$ = `T$`
-export type T$ = typeof T$
-export type TypeTag<T extends string> = `${T$}--${T}`
-export type SingularTypedKey<T extends string = string> = `${T}::${string}`
-export type CompoundTypedKey<
-	A extends string = string,
-	B extends string = string,
-	C extends string = string,
-> = `${TypeTag<A>}==${SingularTypedKey<B>}++${SingularTypedKey<C>}`
-export type TypedKey<
-	A extends string = string,
-	B extends string = string,
-	C extends string = string,
-> = CompoundTypedKey<A, B, C> | SingularTypedKey<A>
-type Scope = SingularTypedKey[]
-type MutualFealty = {
-	above: Scope
-	below: CompoundTypedKey
-}
-type ExclusiveFealty = {
-	above: TypedKey | `root`
-	below: Scope
-}
-type Fealty = ExclusiveFealty | MutualFealty
-
-export type Hierarchy<F extends Fealty[] = Fealty[]> = Each<F>
-
-export type Vassal<H extends Hierarchy> = {
-	[K in keyof H]: H[K] extends MutualFealty
-		? H[K][`below`]
-		: H[K] extends { below: Array<infer V> }
-			? V extends TypedKey
-				? V
-				: never
-			: never
-}[keyof H]
-
-export type Above<TK extends TypedKey, H extends Hierarchy> = {
-	[K in keyof H]: H[K] extends MutualFealty
-		? TK extends H[K][`below`]
-			? H[K][`above`]
-			: never
-		: H[K] extends { below: Array<infer V> }
-			? TK extends V
-				? H[K] extends ExclusiveFealty
-					? H[K][`above`]
-					: never
-				: never
-			: never
-}[keyof H]
-
-export type Below<TK extends TypedKey | TypedKey[], H extends Hierarchy> = {
-	[K in keyof H]: H[K] extends MutualFealty
-		? TK extends H[K][`above`]
-			? H[K][`below`]
-			: TK extends H[K][`above`][number]
-				? H[K][`below`]
-				: never
-		: H[K] extends { above: infer V }
-			? TK extends V
-				? H[K] extends ExclusiveFealty
-					? H[K][`below`][number]
-					: never
-				: never
-			: never
-}[keyof H]
-
-export type Mutuals<TK extends TypedKey | TypedKey[], H extends Hierarchy> = {
-	[K in keyof H]: H[K] extends MutualFealty
-		? TK extends H[K][`above`][number]
-			? [mutual: Exclude<H[K][`above`][number], TK>, below: H[K][`below`]]
-			: never
-		: never
-}[keyof H]
-
-export type CompoundFrom<H extends Hierarchy> = {
-	[K in keyof H]: H[K] extends MutualFealty ? H[K][`below`] : never
-}[keyof H]
-
-export class Anarchy {
-	public store: Store
-	public realm: Realm<any>
-
-	public constructor(store: Store = IMPLICIT.STORE) {
-		this.store = store
-		this.realm = new Realm(store)
-	}
-
-	public allocate(
-		provenance: Canonical,
-		key: Canonical,
-		attachmentStyle?: `all` | `any`,
-	): void {
-		allocateIntoStore<any, any, any>(
-			this.store,
-			provenance,
-			key,
-			attachmentStyle,
-		)
-	}
-
-	public deallocate(key: Canonical): void {
-		deallocateFromStore<any, any>(this.store, key)
-	}
-
-	public claim(
-		newProvenance: Canonical,
-		key: Canonical,
-		exclusive?: `exclusive`,
-	): void {
-		claimWithinStore<any, any, any>(this.store, newProvenance, key, exclusive)
-	}
-}