atom.io 0.32.4 → 0.33.0

package/dist/index.js

@@ -1,2 +0,0 @@
-export { $claim, Anarchy, AtomIOLogger, LOG_LEVELS, Realm, Silo, T$, atom, atomFamily, belongsTo, disposeState, editRelations, findRelations, findState, getInternalRelations, getState, isToken, join, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo } from './chunk-7SJVR7FZ.js';
-import './chunk-XWL6SNVU.js';

package/eslint-plugin/dist/index.d.ts

@@ -1,51 +0,0 @@
-import * as ESTree from 'estree';
-import * as eslint from 'eslint';
-import { Rule } from 'eslint';
-import { ESLintUtils } from '@typescript-eslint/utils';
-
-declare const explicitStateTypes: ESLintUtils.RuleModule<"noTypeArgument", [], unknown, ESLintUtils.RuleListener>;
-
-declare const synchronousSelectorDependencies: {
-    meta: {
-        type: "problem";
-        docs: {
-            description: string;
-            category: string;
-            recommended: false;
-            url: string;
-        };
-        schema: never[];
-    };
-    create(context: Rule.RuleContext): {
-        CallExpression(node: ESTree.CallExpression & Rule.NodeParentExtension): void;
-    };
-};
-
-declare const index_explicitStateTypes: typeof explicitStateTypes;
-declare const index_synchronousSelectorDependencies: typeof synchronousSelectorDependencies;
-declare namespace index {
-  export { index_explicitStateTypes as explicitStateTypes, index_synchronousSelectorDependencies as synchronousSelectorDependencies };
-}
-
-declare const _default: {
-    rules: {
-        "explicit-state-types": any;
-        "synchronous-selector-dependencies": {
-            meta: {
-                type: "problem";
-                docs: {
-                    description: string;
-                    category: string;
-                    recommended: false;
-                    url: string;
-                };
-                schema: never[];
-            };
-            create(context: eslint.Rule.RuleContext): {
-                CallExpression(node: ESTree.CallExpression & eslint.Rule.NodeParentExtension): void;
-            };
-        };
-    };
-};
-
-export { index as Rules, _default as default };

package/eslint-plugin/dist/index.js

@@ -1,238 +0,0 @@
-import { __export } from '../../dist/chunk-XWL6SNVU.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/walk.ts
-function walk(node, callback, depth = 0) {
-  callback(node, depth);
-  switch (node.type) {
-    case `AwaitExpression`:
-      walk(node.argument, callback, depth + 1);
-      break;
-    case `FunctionExpression`:
-    case `ArrowFunctionExpression`:
-      for (const param of node.params) {
-        walk(param, callback, depth + 1);
-      }
-      walk(node.body, callback, depth + 1);
-      break;
-    case `BlockStatement`:
-      for (const statement of node.body) {
-        walk(statement, callback, depth + 1);
-      }
-      break;
-    case `IfStatement`:
-      walk(node.test, callback, depth);
-      walk(node.consequent, callback, depth);
-      if (node.alternate) {
-        walk(node.alternate, callback, depth);
-      }
-      break;
-    case `SwitchStatement`:
-      walk(node.discriminant, callback, depth + 1);
-      for (const caseOrDefault of node.cases) {
-        walk(caseOrDefault, callback, depth);
-      }
-      break;
-    case `ReturnStatement`:
-      if (node.argument) {
-        walk(node.argument, callback, depth);
-      }
-      break;
-    case `SwitchCase`:
-      if (node.test) {
-        walk(node.test, callback, depth);
-      }
-      for (const statement of node.consequent) {
-        walk(statement, callback, depth);
-      }
-      break;
-    case `VariableDeclaration`:
-      for (const declaration of node.declarations) {
-        walk(declaration, callback, depth);
-        if (declaration.init) {
-          walk(declaration.init, callback, depth);
-        }
-      }
-      break;
-    case `BinaryExpression`:
-      walk(node.left, callback, depth);
-      walk(node.right, callback, depth);
-      break;
-    case `ConditionalExpression`:
-      walk(node.test, callback, depth + 1);
-      walk(node.consequent, callback, depth + 1);
-      walk(node.alternate, callback, depth + 1);
-      break;
-    case `MemberExpression`:
-      walk(node.object, callback, depth);
-      walk(node.property, callback, depth);
-      break;
-    case `CallExpression`:
-      walk(node.callee, callback, depth);
-      for (const argument of node.arguments) {
-        walk(argument, callback, depth);
-      }
-      break;
-  }
-}
-
-// eslint-plugin/src/rules/synchronous-selector-dependencies.ts
-var synchronousSelectorDependencies = {
-  meta: {
-    type: `problem`,
-    docs: {
-      description: `disallow await before calling get on the parameter's get method inside selector`,
-      category: `Possible Errors`,
-      recommended: false,
-      url: ``
-      // URL to documentation page for this rule
-    },
-    schema: []
-    // no options
-  },
-  create(context) {
-    return {
-      CallExpression(node) {
-        let selectorComputation;
-        if (`name` in node.callee && node.callee.name === `selectorFamily`) {
-          if (node.arguments[0].type === `ObjectExpression`) {
-            const selectorLookupProperty = node.arguments[0].properties.find(
-              (prop) => {
-                return `key` in prop && `name` in prop.key && prop.key.name === `get`;
-              }
-            );
-            const selectorLookup = selectorLookupProperty?.value;
-            if (selectorLookup?.type === `FunctionExpression` || selectorLookup?.type === `ArrowFunctionExpression`) {
-              if (selectorLookup.body.type === `BlockStatement`) {
-                for (const statement of selectorLookup.body.body) {
-                  if (statement.type === `ReturnStatement` && statement.argument) {
-                    selectorComputation = statement.argument;
-                  }
-                }
-              } else if (selectorLookup.body.type === `FunctionExpression` || selectorLookup.body.type === `ArrowFunctionExpression`) {
-                selectorComputation = selectorLookup.body;
-              }
-            }
-          }
-        }
-        if (`name` in node.callee && node.callee.name === `selector`) {
-          if (node.arguments[0].type === `ObjectExpression`) {
-            const selectorComputationProperty = node.arguments[0].properties.find(
-              (prop) => {
-                return `key` in prop && `name` in prop.key && prop.key.name === `get`;
-              }
-            );
-            selectorComputation = selectorComputationProperty?.value;
-          }
-        }
-        if (selectorComputation?.type === `FunctionExpression` || selectorComputation?.type === `ArrowFunctionExpression`) {
-          const nonDestructuredTransactorsName = selectorComputation.params[0] && `name` in selectorComputation.params[0] ? selectorComputation.params[0].name : void 0;
-          let awaited;
-          let awaitNode;
-          walk(selectorComputation, (n, depth) => {
-            if (typeof awaited === `number`) {
-              if (awaited > depth) {
-                awaited = void 0;
-                awaitNode = void 0;
-              }
-            }
-            switch (n.type) {
-              case `AwaitExpression`:
-                awaited = depth;
-                awaitNode = n;
-                break;
-              case `CallExpression`:
-                if (awaitNode) {
-                  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 === `get`) {
-                        willReport = true;
-                      }
-                      break;
-                    case `Identifier`:
-                      if (n.callee.name === `get`) {
-                        willReport = true;
-                      }
-                      break;
-                  }
-                  if (willReport) {
-                    context.report({
-                      node: awaitNode,
-                      message: `Using await before calling the 'get' transactor is not allowed.`
-                    });
-                  }
-                }
-            }
-          });
-        }
-      }
-    };
-  }
-};
-
-// eslint-plugin/src/index.ts
-var src_default = {
-  rules: {
-    "explicit-state-types": explicitStateTypes,
-    "synchronous-selector-dependencies": synchronousSelectorDependencies
-  }
-};
-
-export { rules_exports as Rules, src_default as default };

package/eslint-plugin/package.json

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

package/internal/dist/index.js

@@ -1,2 +0,0 @@
-export { CircularBuffer, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Join, Junction, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-7SJVR7FZ.js';
-import '../../dist/chunk-XWL6SNVU.js';

package/internal/package.json

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

package/introspection/dist/index.d.ts

@@ -1,149 +0,0 @@
-import { AtomToken, SelectorToken, ReadonlySelectorToken, TransactionToken, ReadonlySelectorFamilyToken, TransactionUpdate, TimelineToken, ReadableToken } from 'atom.io';
-import * as Internal from 'atom.io/internal';
-import { Func, Timeline, Store, Refinement, Flat } from 'atom.io/internal';
-import { Json } from 'atom.io/json';
-
-type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>;
-
-type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown>>;
-
-type IntrospectionStates = {
-    atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
-    selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>;
-    transactionIndex: ReadonlySelectorToken<TransactionToken<Func>[]>;
-    transactionLogSelectors: ReadonlySelectorFamilyToken<TransactionUpdate<Func>[], string>;
-    timelineIndex: ReadonlySelectorToken<TimelineToken<any>[]>;
-    timelineSelectors: ReadonlySelectorFamilyToken<Timeline<any>, string>;
-    typeSelectors: ReadonlySelectorFamilyToken<string, string>;
-};
-declare const attachIntrospectionStates: (store: Store) => IntrospectionStates;
-
-type ListResourcesParam = {
-    atomFamilies: boolean;
-    selectorFamilies: boolean;
-};
-/**
- * Auditor is a tool for identifying lingering resources in your store that may result in memory leaks.
- * @experimental
- */
-declare class Auditor {
-    readonly store: Internal.Store;
-    auditorCreatedAt: number;
-    statesCreatedAt: Map<string, number>;
-    readonly atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
-    readonly selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>;
-    disposed: boolean;
-    private readonly unsubscribeFromAtomCreation;
-    private readonly unsubscribeFromAtomDisposal;
-    private readonly unsubscribeFromSelectorCreation;
-    private readonly unsubscribeFromSelectorDisposal;
-    /**
-     * @param {Store} store - The store to audit.
-     */
-    constructor(store?: Internal.Store);
-    static readonly DEFAULT_LIST_RESOURCES_PARAM: {
-        atomFamilies: true;
-        selectorFamilies: true;
-    };
-    /**
-     * Lists all resources in the store, along with their creation time.
-     *
-     * @param {ListResourcesParam} [param] - Optional parameters for filtering the list of resources.
-     * @returns {readonly [ReadableToken<unknown>, number]}[] - An array of tuples, where each tuple contains a state token belonging to a family in the store and that state's creation time.
-     */
-    listResources(param?: ListResourcesParam): (readonly [ReadableToken<unknown>, number])[];
-    [Symbol.dispose](): void;
-}
-
-type ClassSignature = abstract new (...args: any) => any;
-type RefinementStrategy = ClassSignature | Refinement<unknown, any>;
-type Supported<Refine extends RefinementStrategy> = Refine extends Refinement<unknown, infer T> ? T : Refine extends ClassSignature ? InstanceType<Refine> : never;
-type RefinementSupport = Record<string, RefinementStrategy>;
-declare class Refinery<SupportedTypes extends RefinementSupport> {
-    supported: SupportedTypes;
-    constructor(supported: SupportedTypes);
-    refine<T>(input: T): Flat<{
-        [K in keyof SupportedTypes]: T extends Supported<SupportedTypes[K]> ? {
-            type: K;
-            data: Supported<SupportedTypes[K]>;
-        } : Supported<SupportedTypes[K]> extends T ? {
-            type: K;
-            data: Supported<SupportedTypes[K]>;
-        } : never;
-    }>[keyof SupportedTypes] | (T extends Supported<SupportedTypes[keyof SupportedTypes]> ? never : null);
-}
-declare const primitiveRefinery: Refinery<{
-    number: (input: unknown) => input is number;
-    string: (input: unknown) => input is string;
-    boolean: (input: unknown) => input is boolean;
-    null: (input: unknown) => input is null;
-}>;
-declare function isPlainObject(input: unknown): input is Json.Tree.Object;
-declare const jsonTreeRefinery: Refinery<{
-    object: typeof isPlainObject;
-    array: (input: unknown) => input is Json.Tree.Array;
-}>;
-declare const jsonRefinery: Refinery<{
-    object: typeof isPlainObject;
-    array: (input: unknown) => input is Json.Tree.Array;
-    number: (input: unknown) => input is number;
-    string: (input: unknown) => input is string;
-    boolean: (input: unknown) => input is boolean;
-    null: (input: unknown) => input is null;
-}>;
-type JsonType = keyof typeof jsonRefinery.supported;
-declare const discoverType: (input: unknown) => JsonType | `Map` | `Set` | `undefined` | (string & {});
-
-declare function diffNumber(a: number, b: number): Delta;
-declare function diffString(a: string, b: string): Delta;
-declare function diffBoolean(a: boolean, b: boolean): Delta;
-declare function diffObject(a: Json.Tree.Object, b: Json.Tree.Object, recurse: Diff<unknown>): Delta;
-declare function diffArray(a: Json.Tree.Array, b: Json.Tree.Array, recurse: Diff<unknown>): Delta;
-type Delta = {
-    summary: string;
-    added?: [path: string, addedStringifiedValue: string][];
-    removed?: [path: string, removedStringifiedValue: string][];
-    changed?: [path: string, delta: Delta][];
-};
-type Diff<T> = (a: T, b: T) => Delta;
-type DiffTree<T> = (a: T, b: T, recurse: Differ<any, any>[`diff`]) => Delta;
-declare class Differ<Leaf extends Record<string, any>, Tree extends Record<string, any>> {
-    leafRefinery: Refinery<Leaf>;
-    treeRefinery: Refinery<Tree>;
-    leafDiffers: {
-        [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>>;
-    };
-    treeDiffers: {
-        [KT in keyof Tree]: DiffTree<Supported<Tree[KT]>>;
-    };
-    constructor(leafRefinery: Refinery<Leaf>, treeRefinery: Refinery<Tree>, diffFunctions: {
-        [KT in keyof Tree]: DiffTree<Supported<Tree[KT]>>;
-    } & {
-        [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>>;
-    });
-    diff(a: unknown, b: unknown): Delta;
-}
-declare const prettyJson: Differ<{
-    number: (input: unknown) => input is number;
-    string: (input: unknown) => input is string;
-    boolean: (input: unknown) => input is boolean;
-    null: (input: unknown) => input is null;
-}, {
-    object: typeof isPlainObject;
-    array: (input: unknown) => input is Json.Tree.Array;
-}>;
-
-type InspectionResult = Partial<{
-    pathComplete: true;
-    jobComplete: true;
-}>;
-type InspectNode = (path: string[], node: unknown) => InspectionResult | void;
-declare const sprawl: (tree: Array<unknown> | object, inspector: InspectNode) => void;
-
-type FamilyNode<Token extends ReadableToken<unknown>> = {
-    key: string;
-    familyMembers: Map<string, Token>;
-};
-type WritableTokenIndex<Token extends ReadableToken<unknown>> = Map<string, FamilyNode<Token> | Token>;
-
-export { Auditor, type ClassSignature, Differ, type FamilyNode, type InspectNode, type InspectionResult, type IntrospectionStates, type JsonType, type ListResourcesParam, type RefinementStrategy, type RefinementSupport, Refinery, type Supported, type WritableTokenIndex, attachIntrospectionStates, diffArray, diffBoolean, diffNumber, diffObject, diffString, discoverType, isPlainObject, jsonRefinery, jsonTreeRefinery, prettyJson, primitiveRefinery, sprawl };

package/introspection/dist/index.js

@@ -1,3 +0,0 @@
-export { Auditor, Differ, Refinery, attachIntrospectionStates, diffArray, diffBoolean, diffNumber, diffObject, diffString, discoverType, isPlainObject, jsonRefinery, jsonTreeRefinery, prettyJson, primitiveRefinery, sprawl } from '../../dist/chunk-Q6OOJWM4.js';
-import '../../dist/chunk-7SJVR7FZ.js';
-import '../../dist/chunk-XWL6SNVU.js';

package/introspection/package.json

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

package/json/dist/index.js

@@ -1,2 +0,0 @@
-export { JSON_DEFAULTS, JSON_TYPE_NAMES, fromEntries, isJson, parseJson, selectJson, selectJsonFamily, stringifyJson, toEntries } from '../../dist/chunk-7SJVR7FZ.js';
-import '../../dist/chunk-XWL6SNVU.js';

package/json/package.json

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

package/react/dist/index.js

@@ -1,3 +0,0 @@
-export { StoreContext, StoreProvider, useI, useJSON, useO, useTL } from '../../dist/chunk-TJPLOX7Z.js';
-import '../../dist/chunk-7SJVR7FZ.js';
-import '../../dist/chunk-XWL6SNVU.js';

package/react/package.json

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