atom.io 0.31.1 → 0.32.0

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

@@ -1,216 +1,2 @@
+export { SetRTX } from '../../../dist/chunk-GY2XQYZY.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/web/dist/index.d.ts

@@ -1,4 +1,33 @@
-import { AtomEffect } from 'atom.io';
+/** @public */
+type Effectors<T> = {
+    /**
+     * Set the value of the atom
+     * @param next - The new value of the atom, or a setter function
+     */
+    setSelf: <New extends T>(next: New | Setter<T, New>) => void;
+    /** Subscribe to changes to the atom */
+    onSet: (callback: (options: {
+        newValue: T;
+        oldValue: T;
+    }) => void) => void;
+};
+/**
+ * @public
+ * A function that runs side effects when the atom is set
+ * @param tools - {@link Effectors} that can be used to run side effects
+ * @returns
+ * Optionally, a cleanup function that will be called when the atom is disposed
+ */
+type AtomEffect<T> = (tools: Effectors<T>) => (() => void) | void;
+
+/**
+ * @public
+ * A function that sets the value of a state.
+ * @param oldValue - The current value of the state.
+ * @returns
+ * The new value of the state.
+ */
+type Setter<T, New extends T> = (oldValue: T) => New;
 
 type StringInterface<T> = {
     stringify: (t: T) => string;

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"

package/immortal/src/seek-state.ts

@@ -1,60 +0,0 @@
-import type {
-	MutableAtomFamilyToken,
-	MutableAtomToken,
-	ReadableFamilyToken,
-	ReadableToken,
-	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
-	RegularAtomFamilyToken,
-	RegularAtomToken,
-	WritableFamilyToken,
-	WritableSelectorFamilyToken,
-	WritableSelectorToken,
-	WritableToken,
-} from "atom.io"
-import type { Transceiver } from "atom.io/internal"
-import { IMPLICIT, seekInStore } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
-
-export 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
-
-export function seekState<T, K extends Canonical, Key extends K>(
-	token: RegularAtomFamilyToken<T, K>,
-	key: Key,
-): RegularAtomToken<T, K> | undefined
-
-export function seekState<T, K extends Canonical, Key extends K>(
-	token: WritableSelectorFamilyToken<T, K>,
-	key: Key,
-): WritableSelectorToken<T, K> | undefined
-
-export function seekState<T, K extends Canonical, Key extends K>(
-	token: ReadonlySelectorFamilyToken<T, K>,
-	key: Key,
-): ReadonlySelectorToken<T, K> | undefined
-
-export function seekState<T, K extends Canonical, Key extends K>(
-	token: WritableFamilyToken<T, K>,
-	key: Key,
-): WritableToken<T, K> | undefined
-
-export function seekState<T, K extends Canonical, Key extends K>(
-	token: ReadableFamilyToken<T, K>,
-	key: Key,
-): ReadableToken<T, K> | undefined
-
-export function seekState(
-	token: ReadableFamilyToken<any, any>,
-	key: Canonical,
-): ReadableToken<any> | undefined {
-	const state = seekInStore(IMPLICIT.STORE, token, key)
-	return state
-}