atom.io 0.19.3 → 0.20.0

package/data/dist/index.js

@@ -1,4 +1,4 @@
-export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-MSCJWACE.js';
+export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-SMZRGPN6.js';
 import '../../dist/chunk-FTONNX2R.js';
 import '../../dist/chunk-F2X4B4VY.js';
 import { createStandaloneSelector, findInStore, IMPLICIT, createRegularAtom, createRegularAtomFamily, createSelectorFamily } from 'atom.io/internal';

package/data/src/dict.ts

@@ -1,9 +1,9 @@
 import type * as AtomIO from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createStandaloneSelector,
 	findInStore,
+	IMPLICIT,
 } from "atom.io/internal"
 import type { Json, Stringified } from "atom.io/json"
 

package/data/src/join.ts

@@ -13,13 +13,13 @@ import type {
 import { dispose, findState, getState, setState } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
-	IMPLICIT,
 	createMutableAtomFamily,
 	createRegularAtomFamily,
 	createSelectorFamily,
 	findInStore,
 	getFromStore,
 	getJsonFamily,
+	IMPLICIT,
 	isChildStore,
 	newest,
 	setIntoStore,

package/data/src/struct-family.ts

@@ -1,8 +1,8 @@
 import type * as AtomIO from "atom.io"
 import {
-	IMPLICIT,
 	createRegularAtomFamily,
 	createSelectorFamily,
+	IMPLICIT,
 } from "atom.io/internal"
 
 const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)

package/data/src/struct.ts

@@ -1,8 +1,10 @@
 import type * as AtomIO from "atom.io"
 import type { Store } from "atom.io/internal"
-import { IMPLICIT } from "atom.io/internal"
-
-import { createRegularAtom, createStandaloneSelector } from "atom.io/internal"
+import {
+	createRegularAtom,
+	createStandaloneSelector,
+	IMPLICIT,
+} from "atom.io/internal"
 
 const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
 

package/eslint-plugin/dist/index.cjs

@@ -2,6 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var utils = require('@typescript-eslint/utils');
+
 var __defProp = Object.defineProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -11,8 +13,58 @@ var __export = (target, all) => {
 // eslint-plugin/src/rules/index.ts
 var rules_exports = {};
 __export(rules_exports, {
+  explicitStateTypes: () => explicitStateTypes,
   synchronousSelectorDependencies: () => synchronousSelectorDependencies
 });
+var createRule = utils.ESLintUtils.RuleCreator(
+  (name) => `https://atom.io.fyi/docs/eslint-plugin#${name}`
+);
+var STATE_FUNCTIONS = [`atom`, `atomFamily`, `selector`, `selectorFamily`];
+var explicitStateTypes = createRule({
+  name: `explicit-state-types`,
+  meta: {
+    type: `problem`,
+    docs: {
+      description: `State declarations must have generic type arguments directly passed to them`
+    },
+    messages: {
+      noTypeArgument: `State declarations must have generic type arguments directly passed to them.`
+    },
+    schema: []
+    // no options
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const { callee } = node;
+        switch (callee.type) {
+          case `Identifier`: {
+            if (STATE_FUNCTIONS.includes(callee.name)) {
+              if (!node.typeArguments) {
+                context.report({
+                  node,
+                  messageId: `noTypeArgument`
+                });
+              }
+            }
+            break;
+          }
+          case `MemberExpression`: {
+            if (callee.property.type === `Identifier` && STATE_FUNCTIONS.includes(callee.property.name)) {
+              if (!node.typeArguments) {
+                context.report({
+                  node,
+                  messageId: `noTypeArgument`
+                });
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
 
 // eslint-plugin/src/rules/synchronous-selector-dependencies.ts
 function walk(node, callback, depth = 0) {
@@ -172,6 +224,7 @@ var synchronousSelectorDependencies = {
 // eslint-plugin/src/index.ts
 var src_default = {
   rules: {
+    "explicit-state-types": explicitStateTypes,
     "synchronous-selector-dependencies": synchronousSelectorDependencies
   }
 };

package/eslint-plugin/dist/index.js

@@ -1,10 +1,61 @@
 import { __export } from '../../dist/chunk-F2X4B4VY.js';
+import { ESLintUtils } from '@typescript-eslint/utils';
 
 // eslint-plugin/src/rules/index.ts
 var rules_exports = {};
 __export(rules_exports, {
+  explicitStateTypes: () => explicitStateTypes,
   synchronousSelectorDependencies: () => synchronousSelectorDependencies
 });
+var createRule = ESLintUtils.RuleCreator(
+  (name) => `https://atom.io.fyi/docs/eslint-plugin#${name}`
+);
+var STATE_FUNCTIONS = [`atom`, `atomFamily`, `selector`, `selectorFamily`];
+var explicitStateTypes = createRule({
+  name: `explicit-state-types`,
+  meta: {
+    type: `problem`,
+    docs: {
+      description: `State declarations must have generic type arguments directly passed to them`
+    },
+    messages: {
+      noTypeArgument: `State declarations must have generic type arguments directly passed to them.`
+    },
+    schema: []
+    // no options
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const { callee } = node;
+        switch (callee.type) {
+          case `Identifier`: {
+            if (STATE_FUNCTIONS.includes(callee.name)) {
+              if (!node.typeArguments) {
+                context.report({
+                  node,
+                  messageId: `noTypeArgument`
+                });
+              }
+            }
+            break;
+          }
+          case `MemberExpression`: {
+            if (callee.property.type === `Identifier` && STATE_FUNCTIONS.includes(callee.property.name)) {
+              if (!node.typeArguments) {
+                context.report({
+                  node,
+                  messageId: `noTypeArgument`
+                });
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+});
 
 // eslint-plugin/src/rules/synchronous-selector-dependencies.ts
 function walk(node, callback, depth = 0) {
@@ -164,6 +215,7 @@ var synchronousSelectorDependencies = {
 // eslint-plugin/src/index.ts
 var src_default = {
   rules: {
+    "explicit-state-types": explicitStateTypes,
     "synchronous-selector-dependencies": synchronousSelectorDependencies
   }
 };

package/eslint-plugin/src/index.ts

@@ -6,6 +6,7 @@ export { Rules }
 
 export default {
 	rules: {
+		"explicit-state-types": Rules.explicitStateTypes as any,
 		"synchronous-selector-dependencies": Rules.synchronousSelectorDependencies,
 	},
 } satisfies ESLint.Plugin

package/eslint-plugin/src/rules/explicit-state-types.ts

@@ -0,0 +1,55 @@
+import { ESLintUtils } from "@typescript-eslint/utils"
+
+const createRule = ESLintUtils.RuleCreator(
+	(name) => `https://atom.io.fyi/docs/eslint-plugin#${name}`,
+)
+
+const STATE_FUNCTIONS = [`atom`, `atomFamily`, `selector`, `selectorFamily`]
+
+export const explicitStateTypes = createRule({
+	name: `explicit-state-types`,
+	meta: {
+		type: `problem`,
+		docs: {
+			description: `State declarations must have generic type arguments directly passed to them`,
+		},
+		messages: {
+			noTypeArgument: `State declarations must have generic type arguments directly passed to them.`,
+		},
+		schema: [], // no options
+	},
+	defaultOptions: [],
+	create(context) {
+		return {
+			CallExpression(node) {
+				const { callee } = node
+				switch (callee.type) {
+					case `Identifier`: {
+						if (STATE_FUNCTIONS.includes(callee.name)) {
+							if (!node.typeArguments) {
+								context.report({
+									node,
+									messageId: `noTypeArgument`,
+								})
+							}
+						}
+						break
+					}
+					case `MemberExpression`: {
+						if (
+							callee.property.type === `Identifier` &&
+							STATE_FUNCTIONS.includes(callee.property.name)
+						) {
+							if (!node.typeArguments) {
+								context.report({
+									node,
+									messageId: `noTypeArgument`,
+								})
+							}
+						}
+					}
+				}
+			},
+		}
+	},
+})

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

@@ -1 +1,2 @@
+export * from "./explicit-state-types"
 export * from "./synchronous-selector-dependencies"

package/internal/dist/index.cjs

@@ -23,6 +23,67 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 
+// internal/src/arbitrary.ts
+function arbitrary(random = Math.random) {
+  return random().toString(36).slice(2);
+}
+
+// internal/src/future.ts
+var Future = class extends Promise {
+  constructor(executor) {
+    let promise;
+    let superResolve;
+    let superReject;
+    super((resolve, reject) => {
+      superResolve = resolve;
+      superReject = reject;
+      promise = executor instanceof Promise ? executor : new Promise(executor);
+      promise.then(
+        (value) => {
+          if (promise) {
+            this.pass(promise, value);
+          }
+        },
+        (reason) => {
+          if (promise) {
+            this.fail(promise, reason);
+          }
+        }
+      );
+    });
+    this.destiny = promise;
+    this.resolve = superResolve;
+    this.reject = superReject;
+  }
+  pass(promise, value) {
+    if (promise === this.destiny) {
+      this.resolve(value);
+    }
+  }
+  fail(promise, reason) {
+    if (promise === this.destiny) {
+      this.reject(reason);
+    }
+  }
+  use(value) {
+    if (value instanceof Promise) {
+      const promise = value;
+      this.destiny = promise;
+      promise.then(
+        (resolved) => {
+          this.pass(promise, resolved);
+        },
+        (reason) => {
+          this.fail(promise, reason);
+        }
+      );
+    } else {
+      this.resolve(value);
+      this.destiny = void 0;
+    }
+  }
+};
+
 // internal/src/lineage.ts
 function newest(scion) {
   while (scion.child !== null) {
@@ -539,93 +600,6 @@ function withdrawOrCreate(token, store) {
   }
 }
 
-// internal/src/future.ts
-var Future = class extends Promise {
-  constructor(executor) {
-    super((resolve, reject) => {
-      const pass = (value) => {
-        this.isCanceled ? reject(`canceled`) : resolve(value);
-      };
-      const fail = (reason) => {
-        this.isCanceled ? reject(`canceled`) : reject(reason);
-      };
-      if (typeof executor === `function`) {
-        executor(pass, fail);
-      } else {
-        executor.then(pass, fail);
-      }
-    });
-    this.isCanceled = false;
-  }
-  cancel() {
-    this.isCanceled = true;
-  }
-};
-
-// internal/src/set-state/copy-mutable-if-needed.ts
-function copyMutableIfNeeded(atom, origin, target) {
-  const originValue = origin.valueMap.get(atom.key);
-  const targetValue = target.valueMap.get(atom.key);
-  if (originValue === targetValue) {
-    if (originValue === void 0) {
-      return typeof atom.default === `function` ? atom.default() : atom.default;
-    }
-    origin.logger.info(`\u{1F4C3}`, `atom`, atom.key, `copying`);
-    const jsonValue = atom.toJson(originValue);
-    const copiedValue = atom.fromJson(jsonValue);
-    target.valueMap.set(atom.key, copiedValue);
-    new Tracker(atom, origin);
-    return copiedValue;
-  }
-  return targetValue;
-}
-
-// internal/src/caching.ts
-function cacheValue(key, value, subject, target) {
-  const currentValue = target.valueMap.get(key);
-  if (currentValue instanceof Future) {
-    currentValue.cancel();
-  }
-  if (value instanceof Promise) {
-    const future = new Future(value);
-    target.valueMap.set(key, future);
-    future.then((resolved) => {
-      if (future.isCanceled) {
-        return;
-      }
-      cacheValue(key, resolved, subject, target);
-      subject.next({ newValue: resolved, oldValue: future });
-    }).catch((thrown) => {
-      if (thrown !== `canceled`) {
-        target.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
-      }
-    });
-    return future;
-  }
-  target.valueMap.set(key, value);
-  return value;
-}
-var readCachedValue = (token, target) => {
-  let value = target.valueMap.get(token.key);
-  if (token.type === `mutable_atom` && isChildStore(target)) {
-    const { parent } = target;
-    const copiedValue = copyMutableIfNeeded(token, parent, target);
-    value = copiedValue;
-  }
-  return value;
-};
-var evictCachedValue = (key, target) => {
-  const currentValue = target.valueMap.get(key);
-  if (currentValue instanceof Future) {
-    currentValue.cancel();
-  }
-  if (target.operation.open) {
-    target.operation.prev.set(key, currentValue);
-  }
-  target.valueMap.delete(key);
-  target.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
-};
-
 // internal/src/get-state/read-or-compute-value.ts
 var readOrComputeValue = (state, target) => {
   if (target.valueMap.has(state.key)) {
@@ -1727,6 +1701,72 @@ function isTransceiver(value) {
   return typeof value === `object` && value !== null && `do` in value && `undo` in value && `subscribe` in value;
 }
 
+// internal/src/set-state/copy-mutable-if-needed.ts
+function copyMutableIfNeeded(atom, origin, target) {
+  const originValue = origin.valueMap.get(atom.key);
+  const targetValue = target.valueMap.get(atom.key);
+  if (originValue === targetValue) {
+    if (originValue === void 0) {
+      return typeof atom.default === `function` ? atom.default() : atom.default;
+    }
+    origin.logger.info(`\u{1F4C3}`, `atom`, atom.key, `copying`);
+    const jsonValue = atom.toJson(originValue);
+    const copiedValue = atom.fromJson(jsonValue);
+    target.valueMap.set(atom.key, copiedValue);
+    new Tracker(atom, origin);
+    return copiedValue;
+  }
+  return targetValue;
+}
+
+// internal/src/caching.ts
+function cacheValue(key, value, subject, target) {
+  const currentValue = target.valueMap.get(key);
+  if (currentValue instanceof Future) {
+    const future = currentValue;
+    future.use(value);
+  }
+  if (value instanceof Promise) {
+    const future = new Future(value);
+    target.valueMap.set(key, future);
+    future.then((resolved) => {
+      cacheValue(key, resolved, subject, target);
+      subject.next({ newValue: resolved, oldValue: future });
+    }).catch((thrown) => {
+      target.logger.error(`\u{1F4A5}`, `state`, key, `rejected:`, thrown);
+    });
+    return future;
+  }
+  target.valueMap.set(key, value);
+  return value;
+}
+var readCachedValue = (token, target) => {
+  let value = target.valueMap.get(token.key);
+  if (token.type === `mutable_atom` && isChildStore(target)) {
+    const { parent } = target;
+    const copiedValue = copyMutableIfNeeded(token, parent, target);
+    value = copiedValue;
+  }
+  return value;
+};
+var evictCachedValue = (key, target) => {
+  var _a;
+  const currentValue = target.valueMap.get(key);
+  if (currentValue instanceof Future) {
+    const future = currentValue;
+    const selector = (_a = target.selectors.get(key)) != null ? _a : target.readonlySelectors.get(key);
+    if (selector) {
+      future.use(selector.get());
+    }
+    return;
+  }
+  if (target.operation.open) {
+    target.operation.prev.set(key, currentValue);
+  }
+  target.valueMap.delete(key);
+  target.logger.info(`\u{1F5D1}`, `state`, key, `evicted`);
+};
+
 // internal/src/atom/is-default.ts
 var isAtomDefault = (key, store) => {
   const core = newest(store);
@@ -1856,11 +1896,6 @@ function deleteAtom(atomToken, store) {
   store.logger.info(`\u{1F525}`, `atom`, key, `deleted`);
 }
 
-// internal/src/arbitrary.ts
-function arbitrary(random = Math.random) {
-  return random().toString(36).slice(2);
-}
-
 // internal/src/get-environment-data.ts
 function getEnvironmentData(store) {
   return {

package/internal/dist/index.d.ts

@@ -315,21 +315,21 @@ declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey exten
     constructor(findMutableState: MutableAtomFamily<Core, any, FamilyMemberKey>, store: Store);
 }
 
-declare function createStandaloneAtom<T>(options: RegularAtomOptions<T>, store: Store): RegularAtomToken<T>;
-declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>, store: Store): MutableAtomToken<T, J>;
+declare function arbitrary(random?: () => number): string;
 
 declare function createRegularAtom<T>(options: MutableAtomOptions<any, any> | RegularAtomOptions<T>, family: FamilyMetadata | undefined, store: Store): RegularAtomToken<T>;
 
+declare function createStandaloneAtom<T>(options: RegularAtomOptions<T>, store: Store): RegularAtomToken<T>;
+declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>, store: Store): MutableAtomToken<T, J>;
+
 declare function deleteAtom(atomToken: AtomToken<unknown>, store: Store): void;
 
 declare const isAtomDefault: (key: string, store: Store) => boolean;
 declare const markAtomAsDefault: (key: string, store: Store) => void;
 declare const markAtomAsNotDefault: (key: string, store: Store) => void;
 
-declare function arbitrary(random?: () => number): string;
-
 /**
- * A Promise that can be canceled.
+ * A Promise whose incoming value can be hot swapped.
  * @internal
  * @private
  * @typeParam T The type of the value that the promise will resolve to.
@@ -338,9 +338,13 @@ declare function arbitrary(random?: () => number): string;
  * Can be constructed like a Promise, or from an existing Promise.
  */
 declare class Future<T> extends Promise<T> {
-    isCanceled: boolean;
+    private destiny;
+    private resolve;
+    private reject;
     constructor(executor: Promise<T> | ((resolve: (value: T) => void, reject: (reason?: any) => void) => void));
-    cancel(): void;
+    private pass;
+    private fail;
+    use(value: Promise<T> | T): void;
 }
 
 declare function cacheValue<T>(key: string, value: T, subject: Subject<StateUpdate<unknown>>, store: Store): T;
@@ -351,10 +355,10 @@ declare const evictCachedValue: (key: string, target: Store) => void;
 declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
 declare function createAtomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
 
-declare function createRegularAtomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
-
 declare function createReadonlySelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
 
+declare function createRegularAtomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
+
 declare function createSelectorFamily<T, K extends Json.Serializable>(options: WritableSelectorFamilyOptions<T, K>, store: Store): WritableSelectorFamily<T, K>;
 declare function createSelectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;