atom.io 0.31.1 → 0.32.0

package/dist/index.js

@@ -1,229 +1,2 @@
-import { newest, isChildStore, withdraw } from './chunk-Y5MBNTVU.js';
+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-GY2XQYZY.js';
 import './chunk-XWL6SNVU.js';
-import * as Internal from 'atom.io/internal';
-import { createStandaloneAtom, IMPLICIT, createAtomFamily, makeRootMoleculeInStore, allocateIntoStore, fuseWithinStore, deallocateFromStore, claimWithinStore, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, subscribeInStore, timeTravel, actUponStore, arbitrary } from 'atom.io/internal';
-
-function atom(options) {
-  return createStandaloneAtom(IMPLICIT.STORE, options);
-}
-function atomFamily(options) {
-  return createAtomFamily(IMPLICIT.STORE, options);
-}
-function disposeState(...[token, key]) {
-  if (key) {
-    Internal.disposeFromStore(Internal.IMPLICIT.STORE, token, key);
-  } else {
-    Internal.disposeFromStore(Internal.IMPLICIT.STORE, token);
-  }
-}
-function getState(...params) {
-  if (params.length === 2) {
-    return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params);
-  }
-  return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params);
-}
-
-// src/logger.ts
-var LOG_LEVELS = [`info`, `warn`, `error`];
-var simpleLog = (logLevel) => (icon, denomination, tokenKey, message, ...rest) => {
-  console[logLevel](
-    `${icon} ${denomination} "${tokenKey}" ${message}`,
-    ...rest
-  );
-};
-var simpleLogger = {
-  error: simpleLog(`error`),
-  info: simpleLog(`info`),
-  warn: simpleLog(`warn`)
-};
-var AtomIOLogger = class {
-  constructor(logLevel, filter, logger = simpleLogger) {
-    this.logLevel = logLevel;
-    this.filter = filter;
-    this.logger = logger;
-  }
-  error = (...args) => {
-    if ((this.filter?.(...args) ?? true) && this.logLevel !== null) {
-      this.logger.error(...args);
-    }
-  };
-  info = (...args) => {
-    if ((this.filter?.(...args) ?? true) && this.logLevel === `info`) {
-      this.logger.info(...args);
-    }
-  };
-  warn = (...args) => {
-    if ((this.filter?.(...args) ?? true) && this.logLevel !== `error` && this.logLevel !== null) {
-      this.logger.warn(...args);
-    }
-  };
-};
-var $claim = Symbol(`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 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);
-  }
-};
-var T$ = `T$`;
-function selector(options) {
-  return createStandaloneSelector(IMPLICIT.STORE, options);
-}
-function selectorFamily(options) {
-  return createSelectorFamily(IMPLICIT.STORE, options);
-}
-function setState(...params) {
-  if (params.length === 2) {
-    Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params);
-  } else {
-    Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params);
-  }
-}
-
-// internal/src/install-into-store.ts
-function installIntoStore(tokens, target, source) {
-  const sourceNewest = newest(source);
-  if (isChildStore(sourceNewest)) {
-    source.logger.error(
-      `\u274C`,
-      `transaction`,
-      sourceNewest.transactionMeta.update.key,
-      `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
-      tokens,
-      `${sourceNewest.config.name} is undergoing a transaction.`
-    );
-    return;
-  }
-  const targetNewest = newest(target);
-  if (isChildStore(targetNewest)) {
-    target.logger.error(
-      `\u274C`,
-      `transaction`,
-      targetNewest.transactionMeta.update.key,
-      `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
-      tokens,
-      `${targetNewest.config.name} is undergoing a transaction.`
-    );
-    return;
-  }
-  for (const token of tokens) {
-    const resource = withdraw(token, source);
-    resource.install(target);
-  }
-}
-
-// src/silo.ts
-var Silo = class {
-  store;
-  atom;
-  atomFamily;
-  selector;
-  selectorFamily;
-  transaction;
-  timeline;
-  findState;
-  getState;
-  setState;
-  disposeState;
-  subscribe;
-  undo;
-  redo;
-  runTransaction;
-  install;
-  constructor(config, fromStore = null) {
-    const s = this.store = new Store(config, fromStore);
-    this.atom = (options) => createStandaloneAtom(s, options);
-    this.atomFamily = (options) => createAtomFamily(s, options);
-    this.selector = (options) => createStandaloneSelector(s, options);
-    this.selectorFamily = (options) => createSelectorFamily(s, options);
-    this.transaction = (options) => createTransaction(options, s);
-    this.timeline = (options) => createTimeline(options, s);
-    this.findState = (...params) => findInStore(s, ...params);
-    this.getState = (...params) => getFromStore(s, ...params);
-    this.setState = (...params) => {
-      setIntoStore(s, ...params);
-    };
-    this.disposeState = (...params) => {
-      disposeFromStore(s, ...params);
-    };
-    this.subscribe = (...params) => subscribeInStore(s, ...params);
-    this.undo = (token) => {
-      timeTravel(s, `undo`, token);
-    };
-    this.redo = (token) => {
-      timeTravel(s, `redo`, token);
-    };
-    this.runTransaction = (token, id = arbitrary()) => actUponStore(token, id, s);
-    this.install = (tokens, source = IMPLICIT.STORE) => {
-      installIntoStore(tokens, s, source);
-    };
-  }
-};
-function subscribe(token, handleUpdate, key = arbitrary()) {
-  return subscribeInStore(IMPLICIT.STORE, token, handleUpdate, key);
-}
-var timeline = (options) => {
-  return createTimeline(options, IMPLICIT.STORE);
-};
-var redo = (tl) => {
-  timeTravel(IMPLICIT.STORE, `redo`, tl);
-};
-var undo = (tl) => {
-  timeTravel(IMPLICIT.STORE, `undo`, tl);
-};
-function transaction(options) {
-  return createTransaction(options, IMPLICIT.STORE);
-}
-function runTransaction(token, id = arbitrary()) {
-  return actUponStore(token, id, IMPLICIT.STORE);
-}
-
-// src/validators.ts
-function isToken(knownToken, unknownToken) {
-  return knownToken.key === unknownToken.key;
-}
-function belongsTo(family, unknownToken) {
-  return family.key === unknownToken.family?.key;
-}
-
-export { $claim, Anarchy, AtomIOLogger, LOG_LEVELS, Realm, Silo, T$, atom, atomFamily, belongsTo, disposeState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

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

@@ -6,33 +6,6 @@ import { ESLintUtils } from '@typescript-eslint/utils';
 
 declare const explicitStateTypes: ESLintUtils.RuleModule<"noTypeArgument", [], unknown, ESLintUtils.RuleListener>;
 
-declare const lifespan: {
-    meta: {
-        type: "problem";
-        docs: {
-            description: string;
-            category: string;
-            recommended: false;
-            url: string;
-        };
-        schema: {
-            type: "string";
-            enum: string[];
-            default: string;
-        }[];
-    };
-    create(context: _eslint_core.RuleContext<{
-        LangOptions: eslint.Linter.LanguageOptions;
-        Code: eslint.SourceCode;
-        RuleOptions: any[];
-        Node: ESTree.Node;
-        MessageIds: string;
-    }>): {
-        ImportDeclaration(node: ESTree.ImportDeclaration & Rule.NodeParentExtension): void;
-        CallExpression(node: ESTree.CallExpression & Rule.NodeParentExtension): void;
-    };
-};
-
 declare const synchronousSelectorDependencies: {
     meta: {
         type: "problem";
@@ -56,16 +29,14 @@ declare const synchronousSelectorDependencies: {
 };
 
 declare const index_explicitStateTypes: typeof explicitStateTypes;
-declare const index_lifespan: typeof lifespan;
 declare const index_synchronousSelectorDependencies: typeof synchronousSelectorDependencies;
 declare namespace index {
-  export { index_explicitStateTypes as explicitStateTypes, index_lifespan as lifespan, index_synchronousSelectorDependencies as synchronousSelectorDependencies };
+  export { index_explicitStateTypes as explicitStateTypes, index_synchronousSelectorDependencies as synchronousSelectorDependencies };
 }
 
 declare const _default: {
     rules: {
         "explicit-state-types": any;
-        lifespan: any;
         "synchronous-selector-dependencies": {
             meta: {
                 type: "problem";

package/eslint-plugin/dist/index.js

@@ -5,7 +5,6 @@ import { ESLintUtils } from '@typescript-eslint/utils';
 var rules_exports = {};
 __export(rules_exports, {
   explicitStateTypes: () => explicitStateTypes,
-  lifespan: () => lifespan,
   synchronousSelectorDependencies: () => synchronousSelectorDependencies
 });
 var createRule = ESLintUtils.RuleCreator(
@@ -133,150 +132,6 @@ function walk(node, callback, depth = 0) {
   }
 }
 
-// eslint-plugin/src/rules/lifespan.ts
-var 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`;
-    return {
-      ImportDeclaration(node) {
-        const importSource = node.source.value;
-        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 = [];
-        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) => {
-                      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) => {
-                      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) => {
-            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.`
-                });
-              }
-            }
-          });
-        }
-      }
-    };
-  }
-};
-
 // eslint-plugin/src/rules/synchronous-selector-dependencies.ts
 var synchronousSelectorDependencies = {
   meta: {
@@ -376,7 +231,6 @@ var synchronousSelectorDependencies = {
 var src_default = {
   rules: {
     "explicit-state-types": explicitStateTypes,
-    lifespan,
     "synchronous-selector-dependencies": synchronousSelectorDependencies
   }
 };

package/eslint-plugin/src/index.ts

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

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

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