atom.io 0.31.1 → 0.32.1

package/transceivers/set-rtx/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { Transceiver, Lineage, TransceiverMode, Subject } from 'atom.io/internal';
 import { primitive, Json } from 'atom.io/json';
 
-type SetUpdate = `add:${string}` | `clear:${string}` | `del:${string}` | `tx:${string}`;
+type SetUpdateType = `add` | `clear` | `del` | `tx`;
+type SetUpdate = `${SetUpdateType}:${string}`;
 type NumberedSetUpdate = `${number}=${SetUpdate}`;
 interface SetRTXJson<P extends primitive> extends Json.Object {
     members: P[];
@@ -12,7 +13,7 @@ interface SetRTXJson<P extends primitive> extends Json.Object {
 }
 declare class SetRTX<P extends primitive> extends Set<P> implements Transceiver<NumberedSetUpdate>, Lineage {
     mode: TransceiverMode;
-    readonly subject: Subject<SetUpdate>;
+    readonly subject: Subject<`add:${string}` | `clear:${string}` | `del:${string}` | `tx:${string}`>;
     cacheLimit: number;
     cache: (NumberedSetUpdate | null)[];
     cacheIdx: number;
@@ -37,4 +38,4 @@ declare class SetRTX<P extends primitive> extends Set<P> implements Transceiver<
     undo(update: NumberedSetUpdate): number | null;
 }
 
-export { type NumberedSetUpdate, SetRTX, type SetRTXJson, type SetUpdate };
+export { type NumberedSetUpdate, SetRTX, type SetRTXJson, type SetUpdate, type SetUpdateType };

package/transceivers/set-rtx/dist/index.js

@@ -1,216 +1,2 @@
+export { SetRTX } from '../../../dist/chunk-UQEYZ3OI.js';
 import '../../../dist/chunk-XWL6SNVU.js';
-import { Subject } from 'atom.io/internal';
-import { stringifyJson } from 'atom.io/json';
-
-var SetRTX = class _SetRTX extends Set {
-  mode = `record`;
-  subject = new Subject();
-  cacheLimit = 0;
-  cache = [];
-  cacheIdx = -1;
-  cacheUpdateNumber = -1;
-  constructor(values, cacheLimit = 0) {
-    super(values);
-    if (values instanceof _SetRTX) {
-      this.parent = values;
-      this.cacheUpdateNumber = values.cacheUpdateNumber;
-    }
-    if (cacheLimit) {
-      this.cacheLimit = cacheLimit;
-      this.cache = new Array(cacheLimit);
-      this.subscribe(`auto cache`, (update) => {
-        this.cacheIdx++;
-        this.cacheIdx %= this.cacheLimit;
-        this.cache[this.cacheIdx] = update;
-      });
-    }
-  }
-  toJSON() {
-    return {
-      members: [...this],
-      cache: this.cache,
-      cacheLimit: this.cacheLimit,
-      cacheIdx: this.cacheIdx,
-      cacheUpdateNumber: this.cacheUpdateNumber
-    };
-  }
-  static fromJSON(json) {
-    const set = new _SetRTX(json.members, json.cacheLimit);
-    set.cache = json.cache;
-    set.cacheIdx = json.cacheIdx;
-    set.cacheUpdateNumber = json.cacheUpdateNumber;
-    return set;
-  }
-  add(value) {
-    const result = super.add(value);
-    if (this.mode === `record`) {
-      this.cacheUpdateNumber++;
-      this.emit(`add:${stringifyJson(value)}`);
-    }
-    return result;
-  }
-  clear() {
-    const capturedContents = this.mode === `record` ? [...this] : null;
-    super.clear();
-    if (capturedContents) {
-      this.cacheUpdateNumber++;
-      this.emit(`clear:${JSON.stringify(capturedContents)}`);
-    }
-  }
-  delete(value) {
-    const result = super.delete(value);
-    if (this.mode === `record`) {
-      this.cacheUpdateNumber++;
-      this.emit(`del:${stringifyJson(value)}`);
-    }
-    return result;
-  }
-  parent;
-  child = null;
-  transactionUpdates = null;
-  transaction(run) {
-    this.mode = `transaction`;
-    this.transactionUpdates = [];
-    this.child = new _SetRTX(this);
-    const unsubscribe = this.child._subscribe(`transaction`, (update) => {
-      this.transactionUpdates?.push(update);
-    });
-    try {
-      const shouldCommit = run(this.child);
-      if (shouldCommit) {
-        for (const update of this.transactionUpdates) {
-          this.doStep(update);
-        }
-        this.cacheUpdateNumber++;
-        this.emit(`tx:${this.transactionUpdates.join(`;`)}`);
-      }
-    } catch (thrown) {
-      console.warn(
-        `Did not apply transaction to SetRTX; this error was thrown:`,
-        thrown
-      );
-      throw thrown;
-    } finally {
-      unsubscribe();
-      this.child = null;
-      this.transactionUpdates = null;
-      this.mode = `record`;
-    }
-  }
-  _subscribe(key, fn) {
-    return this.subject.subscribe(key, fn);
-  }
-  subscribe(key, fn) {
-    return this.subject.subscribe(key, (update) => {
-      fn(`${this.cacheUpdateNumber}=${update}`);
-    });
-  }
-  emit(update) {
-    this.subject.next(update);
-  }
-  doStep(update) {
-    const typeValueBreak = update.indexOf(`:`);
-    const type = update.substring(0, typeValueBreak);
-    const value = update.substring(typeValueBreak + 1);
-    switch (type) {
-      case `add`:
-        this.add(JSON.parse(value));
-        break;
-      case `clear`:
-        this.clear();
-        break;
-      case `del`:
-        this.delete(JSON.parse(value));
-        break;
-      case `tx`:
-        for (const subUpdate of value.split(`;`)) {
-          this.doStep(subUpdate);
-        }
-    }
-  }
-  getUpdateNumber(update) {
-    const breakpoint = update.indexOf(`=`);
-    return Number(update.substring(0, breakpoint));
-  }
-  do(update) {
-    const breakpoint = update.indexOf(`=`);
-    const updateNumber = Number(update.substring(0, breakpoint));
-    const eventOffset = updateNumber - this.cacheUpdateNumber;
-    const isFuture = eventOffset > 0;
-    if (isFuture) {
-      if (eventOffset === 1) {
-        this.mode = `playback`;
-        const innerUpdate = update.substring(breakpoint + 1);
-        this.doStep(innerUpdate);
-        this.mode = `record`;
-        this.cacheUpdateNumber = updateNumber;
-        return null;
-      }
-      return this.cacheUpdateNumber + 1;
-    }
-    if (Math.abs(eventOffset) < this.cacheLimit) {
-      const eventIdx = this.cacheIdx + eventOffset;
-      const cachedUpdate = this.cache[eventIdx];
-      if (cachedUpdate === update) {
-        return null;
-      }
-      this.mode = `playback`;
-      let done = false;
-      while (!done) {
-        this.cacheIdx %= this.cacheLimit;
-        const u = this.cache[this.cacheIdx];
-        this.cacheIdx--;
-        if (!u) {
-          return `OUT_OF_RANGE`;
-        }
-        this.undo(u);
-        done = this.cacheIdx === eventIdx - 1;
-      }
-      const innerUpdate = update.substring(breakpoint + 1);
-      this.doStep(innerUpdate);
-      this.mode = `record`;
-      this.cacheUpdateNumber = updateNumber;
-      return null;
-    }
-    return `OUT_OF_RANGE`;
-  }
-  undoStep(update) {
-    const breakpoint = update.indexOf(`:`);
-    const type = update.substring(0, breakpoint);
-    const value = update.substring(breakpoint + 1);
-    switch (type) {
-      case `add`:
-        this.delete(JSON.parse(value));
-        break;
-      case `del`:
-        this.add(JSON.parse(value));
-        break;
-      case `clear`: {
-        const values = JSON.parse(value);
-        for (const v of values) this.add(v);
-        break;
-      }
-      case `tx`: {
-        const updates = value.split(`;`);
-        for (let i = updates.length - 1; i >= 0; i--) {
-          this.undoStep(updates[i]);
-        }
-      }
-    }
-  }
-  undo(update) {
-    const breakpoint = update.indexOf(`=`);
-    const updateNumber = Number(update.substring(0, breakpoint));
-    if (updateNumber === this.cacheUpdateNumber) {
-      this.mode = `playback`;
-      const innerUpdate = update.substring(breakpoint + 1);
-      this.undoStep(innerUpdate);
-      this.mode = `record`;
-      this.cacheUpdateNumber--;
-      return null;
-    }
-    return this.cacheUpdateNumber;
-  }
-};
-
-export { SetRTX };

package/transceivers/set-rtx/src/set-rtx.ts

@@ -3,11 +3,8 @@ import { Subject } from "atom.io/internal"
 import type { Json, primitive } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-export type SetUpdate =
-	| `add:${string}`
-	| `clear:${string}`
-	| `del:${string}`
-	| `tx:${string}`
+export type SetUpdateType = `add` | `clear` | `del` | `tx`
+export type SetUpdate = `${SetUpdateType}:${string}`
 export type NumberedSetUpdate = `${number}=${SetUpdate}`
 
 export interface SetRTXJson<P extends primitive> extends Json.Object {
@@ -145,7 +142,7 @@ export class SetRTX<P extends primitive>
 
 	private doStep(update: SetUpdate): void {
 		const typeValueBreak = update.indexOf(`:`)
-		const type = update.substring(0, typeValueBreak)
+		const type = update.substring(0, typeValueBreak) as SetUpdateType
 		const value = update.substring(typeValueBreak + 1)
 		switch (type) {
 			case `add`:
@@ -214,7 +211,7 @@ export class SetRTX<P extends primitive>
 
 	public undoStep(update: SetUpdate): void {
 		const breakpoint = update.indexOf(`:`)
-		const type = update.substring(0, breakpoint)
+		const type = update.substring(0, breakpoint) as SetUpdateType
 		const value = update.substring(breakpoint + 1)
 		switch (type) {
 			case `add`:

package/web/dist/index.js

@@ -1,16 +1,2 @@
+export { persistSync } from '../../dist/chunk-4LWKCEW3.js';
 import '../../dist/chunk-XWL6SNVU.js';
-
-// web/src/persist-sync.ts
-var persistSync = (storage, { stringify, parse }, key) => ({ setSelf, onSet }) => {
-  const savedValue = storage.getItem(key);
-  if (savedValue != null) setSelf(parse(savedValue));
-  onSet(({ newValue }) => {
-    if (newValue == null) {
-      storage.removeItem(key);
-      return;
-    }
-    storage.setItem(key, stringify(newValue));
-  });
-};
-
-export { persistSync };

package/data/src/until.ts

@@ -1,15 +0,0 @@
-export type Loadable<T> = Promise<T> | T
-export type Fated<T, E extends Error = Error> = Loadable<E | T>
-
-/**
- * Utility for handling loadable values
- * @param loadable Loadable value
- * @param fallback Fallback value until Loadable is resolved
- * @returns Fallback value if your loadable is a promise, otherwise the loadable's resolved value
- */
-export function until<T>(loadable: Loadable<T>, fallback: T): T {
-	if (loadable instanceof Promise) {
-		return fallback
-	}
-	return loadable
-}

package/ephemeral/dist/index.d.ts

@@ -1,67 +0,0 @@
-import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken } from 'atom.io';
-import { Transceiver } from 'atom.io/internal';
-import { Json, Canonical } from 'atom.io/json';
-
-/**
- * @public
- * Finds a {@link MutableAtomToken} in the store
- * @param token - A {@link MutableAtomFamilyToken}
- * @param key - The key of the state
- * @returns
- * The current value of the state
- * @overload Mutable Atom
- */
-declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
-/**
- * @public
- * Finds a state in the store
- * @param token - The token of the state family
- * @param key - The key of the state
- * @returns
- * The current value of the state
- * @overload Regular Atom
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
-/**
- * @public
- * Finds a state in the store
- * @param token - The token of the state family
- * @param key - The key of the state
- * @returns
- * The current value of the state
- * @overload Writable Selector
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K>;
-/**
- * @public
- * Finds a state in the store
- * @param token - The token of the state family
- * @param key - The key of the state
- * @returns
- * The current value of the state
- * @overload Readonly Selector
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K>;
-/**
- * @public
- * Finds a state in the store
- * @param token - The token of the state family
- * @param key - The key of the state
- * @returns
- * The current value of the state
- * @overload Writable State
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K>;
-/**
- * @public
- * Finds a {@link ReadableToken} in the store
- * @param token - A {@link ReadableFamilyToken}
- * @param key - The key of the state
- * @returns
- * The current value of the state
- * @overload Unknown
- * @default
- */
-declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
-
-export { findState };

package/ephemeral/dist/index.js

@@ -1,9 +0,0 @@
-import '../../dist/chunk-XWL6SNVU.js';
-import { findInStore, IMPLICIT } from 'atom.io/internal';
-
-function findState(token, key) {
-  const state = findInStore(IMPLICIT.STORE, token, key);
-  return state;
-}
-
-export { findState };

package/ephemeral/package.json

@@ -1,13 +0,0 @@
-{
-	"name": "atom.io-ephemeral",
-	"type": "module",
-	"private": true,
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
-	"exports": {
-		".": {
-			"import": "./dist/index.js",
-			"types": "./dist/index.d.ts"
-		}
-	}
-}

package/ephemeral/src/index.ts

@@ -1 +0,0 @@
-export * from "./find-state"

package/eslint-plugin/src/rules/lifespan.ts

@@ -1,203 +0,0 @@
-import type { Rule } from "eslint"
-import type * as ESTree from "estree"
-
-import { walk } from "../walk"
-
-export const lifespan = {
-	meta: {
-		type: `problem`,
-		docs: {
-			description: `atom.io provides tools for short-lived (ephemeral) and long-lived (immortal) stores. This rule allows you to guard against unsafe usage of tools for the other type of store.`,
-			category: `Possible Errors`,
-			recommended: false,
-			url: ``, // URL to documentation page for this rule
-		},
-		schema: [
-			{
-				type: `string`,
-				enum: [`ephemeral`, `immortal`],
-				default: `ephemeral`,
-			},
-		],
-	},
-	create(context) {
-		const storeLifespan = (context.options[0] ?? `ephemeral`) as
-			| `ephemeral`
-			| `immortal`
-		return {
-			ImportDeclaration(node) {
-				const importSource = node.source.value as string
-				if (!importSource.startsWith(`atom.io/`)) {
-					return
-				}
-				const [_, subPackageName] = importSource.split(`/`)
-				if (storeLifespan === `immortal` && subPackageName === `ephemeral`) {
-					context.report({
-						node,
-						message: `do not import from "${importSource}" in an ${storeLifespan} store`,
-					})
-				}
-			},
-
-			CallExpression(node) {
-				if (storeLifespan === `ephemeral`) {
-					return
-				}
-
-				const functionCallee =
-					node.callee.type === `Identifier` ? node.callee : undefined
-				const methodCallee =
-					node.callee.type === `MemberExpression` &&
-					node.callee.property.type === `Identifier`
-						? node.callee.property
-						: undefined
-				const callee = functionCallee ?? methodCallee
-
-				if (callee === undefined) {
-					return
-				}
-
-				if (callee.name === `findState`) {
-					context.report({
-						node,
-						message: `do not use findState in an ${storeLifespan} store`,
-					})
-				}
-
-				const storeProcedures: (
-					| ESTree.ArrowFunctionExpression
-					| ESTree.FunctionExpression
-				)[] = []
-				if (
-					callee.name === `selector` ||
-					callee.name === `selectorFamily` ||
-					callee.name === `transaction`
-				) {
-					if (node.arguments[0].type === `ObjectExpression`) {
-						const argProperties = node.arguments[0].properties
-						switch (callee.name) {
-							case `selector`:
-							case `selectorFamily`:
-								{
-									const getAndSetProps = argProperties.filter(
-										(prop): prop is ESTree.Property => {
-											return (
-												`key` in prop &&
-												`name` in prop.key &&
-												(prop.key.name === `get` || prop.key.name === `set`)
-											)
-										},
-									)
-									switch (callee.name) {
-										case `selector`:
-											{
-												for (const prop of getAndSetProps) {
-													if (
-														prop.value.type === `FunctionExpression` ||
-														prop.value.type === `ArrowFunctionExpression`
-													) {
-														storeProcedures.push(prop.value)
-													}
-												}
-											}
-											break
-										case `selectorFamily`:
-											{
-												for (const prop of getAndSetProps) {
-													const { value } = prop
-													if (
-														value.type === `FunctionExpression` ||
-														value.type === `ArrowFunctionExpression`
-													) {
-														if (value.body.type === `BlockStatement`) {
-															for (const statement of value.body.body) {
-																if (
-																	statement.type === `ReturnStatement` &&
-																	statement.argument &&
-																	(statement.argument.type ===
-																		`FunctionExpression` ||
-																		statement.argument.type ===
-																			`ArrowFunctionExpression`)
-																) {
-																	storeProcedures.push(statement.argument)
-																}
-															}
-														} else if (
-															value.body.type === `FunctionExpression` ||
-															value.body.type === `ArrowFunctionExpression`
-														) {
-															storeProcedures.push(value.body)
-														}
-													}
-												}
-											}
-											break
-									}
-								}
-								break
-
-							case `transaction`:
-								{
-									const doProp = argProperties.find(
-										(prop): prop is ESTree.Property => {
-											return (
-												`key` in prop &&
-												`name` in prop.key &&
-												prop.key.name === `do`
-											)
-										},
-									)
-									if (doProp) {
-										if (
-											doProp.value.type === `FunctionExpression` ||
-											doProp.value.type === `ArrowFunctionExpression`
-										) {
-											storeProcedures.push(doProp.value)
-										}
-									}
-								}
-								break
-						}
-					}
-				}
-
-				for (const storeProcedure of storeProcedures) {
-					const transactorsParam = storeProcedure.params[0]
-					const nonDestructuredTransactorsName =
-						transactorsParam && `name` in transactorsParam
-							? transactorsParam.name
-							: undefined
-					walk(storeProcedure.body, (n) => {
-						// console.log(`${`\t`.repeat(depth)}${n.type} ${n.name ?? ``}`)
-						if (n.type === `CallExpression`) {
-							let willReport = false
-							switch (n.callee.type) {
-								case `MemberExpression`:
-									if (
-										n.callee.object.type === `Identifier` &&
-										n.callee.object.name === nonDestructuredTransactorsName &&
-										n.callee.property.type === `Identifier` &&
-										n.callee.property.name === `find`
-									) {
-										willReport = true
-									}
-									break
-								case `Identifier`:
-									if (n.callee.name === `find`) {
-										willReport = true
-									}
-									break
-							}
-							if (willReport) {
-								context.report({
-									node: n,
-									message: `Using find in a transactor is not allowed in an immortal store.`,
-								})
-							}
-						}
-					})
-				}
-			},
-		}
-	},
-} satisfies Rule.RuleModule

package/immortal/dist/index.d.ts

@@ -1,12 +0,0 @@
-import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken } from 'atom.io';
-import { Transceiver } from 'atom.io/internal';
-import { Json, Canonical } from 'atom.io/json';
-
-declare function seekState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K> | undefined;
-declare function seekState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K> | undefined;
-declare function seekState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K> | undefined;
-declare function seekState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K> | undefined;
-declare function seekState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K> | undefined;
-declare function seekState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K> | undefined;
-
-export { seekState };

package/immortal/dist/index.js

@@ -1,9 +0,0 @@
-import '../../dist/chunk-XWL6SNVU.js';
-import { seekInStore, IMPLICIT } from 'atom.io/internal';
-
-function seekState(token, key) {
-  const state = seekInStore(IMPLICIT.STORE, token, key);
-  return state;
-}
-
-export { seekState };

package/immortal/package.json

@@ -1,13 +0,0 @@
-{
-	"name": "atom.io-immortal",
-	"type": "module",
-	"private": true,
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
-	"exports": {
-		".": {
-			"import": "./dist/index.js",
-			"types": "./dist/index.d.ts"
-		}
-	}
-}

package/immortal/src/index.ts

@@ -1 +0,0 @@
-export * from "./seek-state"