atom.io 0.25.6 → 0.26.0

package/dist/chunk-S4N6XNPH.js

@@ -1,38 +0,0 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __restKey = (key) => typeof key === "symbol" ? key : key + "";
-var __objRest = (source, exclude) => {
-  var target = {};
-  for (var prop in source)
-    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
-      target[prop] = source[prop];
-  if (source != null && __getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(source)) {
-      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
-        target[prop] = source[prop];
-    }
-  return target;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-export { __export, __objRest, __restKey, __spreadProps, __spreadValues };

package/dist/index.cjs

@@ -1,215 +0,0 @@
-'use strict';
-
-var Internal = require('atom.io/internal');
-var json = require('atom.io/json');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var Internal__namespace = /*#__PURE__*/_interopNamespace(Internal);
-
-// src/atom.ts
-function atom(options) {
-  return Internal.createStandaloneAtom(options, Internal.IMPLICIT.STORE);
-}
-function atomFamily(options) {
-  return Internal.createAtomFamily(options, Internal.IMPLICIT.STORE);
-}
-function disposeState(token, key) {
-  if (key) {
-    Internal__namespace.disposeFromStore(token, key, Internal__namespace.IMPLICIT.STORE);
-  } else {
-    Internal__namespace.disposeFromStore(token, Internal__namespace.IMPLICIT.STORE);
-  }
-}
-function getState(token, key) {
-  if (key) {
-    return Internal__namespace.getFromStore(
-      token,
-      key,
-      Internal__namespace.IMPLICIT.STORE
-    );
-  }
-  return Internal__namespace.getFromStore(token, Internal__namespace.IMPLICIT.STORE);
-}
-
-// 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;
-    this.error = (...args) => {
-      var _a, _b;
-      if (((_b = (_a = this.filter) == null ? void 0 : _a.call(this, ...args)) != null ? _b : true) && this.logLevel !== null) {
-        this.logger.error(...args);
-      }
-    };
-    this.info = (...args) => {
-      var _a, _b;
-      if (((_b = (_a = this.filter) == null ? void 0 : _a.call(this, ...args)) != null ? _b : true) && this.logLevel === `info`) {
-        this.logger.info(...args);
-      }
-    };
-    this.warn = (...args) => {
-      var _a, _b;
-      if (((_b = (_a = this.filter) == null ? void 0 : _a.call(this, ...args)) != null ? _b : true) && this.logLevel !== `error` && this.logLevel !== null) {
-        this.logger.warn(...args);
-      }
-    };
-  }
-};
-function moleculeFamily(options) {
-  return Internal.createMoleculeFamily(options, Internal.IMPLICIT.STORE);
-}
-function makeMolecule(context, family, key, ...params) {
-  return Internal.makeMoleculeInStore(Internal.IMPLICIT.STORE, context, family, key, ...params);
-}
-function makeRootMolecule(key, store = Internal.IMPLICIT.STORE) {
-  const molecule = new Internal.Molecule(void 0, key);
-  store.molecules.set(json.stringifyJson(key), molecule);
-  return {
-    key,
-    type: `molecule`
-  };
-}
-function selector(options) {
-  return Internal.createStandaloneSelector(options, Internal.IMPLICIT.STORE);
-}
-function selectorFamily(options) {
-  return Internal.createSelectorFamily(options, Internal.IMPLICIT.STORE);
-}
-function setState(token, p1, p2) {
-  if (p2) {
-    Internal__namespace.setIntoStore(token, p1, p2, Internal__namespace.IMPLICIT.STORE);
-  } else {
-    Internal__namespace.setIntoStore(token, p1, Internal__namespace.IMPLICIT.STORE);
-  }
-}
-var Silo = class {
-  constructor(config, fromStore = null) {
-    const s = new Internal.Store(config, fromStore);
-    function _atom(options) {
-      return Internal.createStandaloneAtom(options, s);
-    }
-    function _atomFamily(options) {
-      return Internal.createAtomFamily(options, s);
-    }
-    this.store = s;
-    this.atom = _atom;
-    this.atomFamily = _atomFamily;
-    this.selector = (options) => Internal.createStandaloneSelector(options, s);
-    this.selectorFamily = (options) => Internal.createSelectorFamily(options, s);
-    this.transaction = (options) => Internal.createTransaction(options, s);
-    this.timeline = (options) => Internal.createTimeline(options, s);
-    this.findState = (token, key) => Internal.findInStore(token, key, s);
-    this.getState = (...params) => Internal.getFromStore(...params, s);
-    this.setState = (...params) => {
-      Internal.setIntoStore(...params, s);
-    };
-    this.disposeState = (...params) => {
-      Internal.disposeFromStore(...params, s);
-    };
-    this.subscribe = (token, handler, key) => subscribe(token, handler, key, s);
-    this.undo = (token) => {
-      Internal.timeTravel(`undo`, token, s);
-    };
-    this.redo = (token) => {
-      Internal.timeTravel(`redo`, token, s);
-    };
-    this.moleculeFamily = (...params) => {
-      return Internal.createMoleculeFamily(...params, s);
-    };
-    this.makeMolecule = (...params) => {
-      return Internal.makeMoleculeInStore(s, ...params);
-    };
-  }
-};
-function subscribe(token, handleUpdate, key = Internal.arbitrary(), store = Internal.IMPLICIT.STORE) {
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-    case `readonly_selector`:
-    case `selector`:
-      return Internal.subscribeToState(token, handleUpdate, key, store);
-    case `transaction`:
-      return Internal.subscribeToTransaction(token, handleUpdate, key, store);
-    case `timeline`:
-      return Internal.subscribeToTimeline(token, handleUpdate, key, store);
-  }
-}
-var timeline = (options) => {
-  return Internal.createTimeline(options, Internal.IMPLICIT.STORE);
-};
-var redo = (tl) => {
-  Internal.timeTravel(`redo`, tl, Internal.IMPLICIT.STORE);
-};
-var undo = (tl) => {
-  Internal.timeTravel(`undo`, tl, Internal.IMPLICIT.STORE);
-};
-function transaction(options) {
-  return Internal.createTransaction(options, Internal.IMPLICIT.STORE);
-}
-function runTransaction(token, id = Internal.arbitrary()) {
-  return Internal.actUponStore(token, id, Internal.IMPLICIT.STORE);
-}
-
-// src/validators.ts
-function isToken(knownToken, unknownToken) {
-  return knownToken.key === unknownToken.key;
-}
-function belongsTo(family, unknownToken) {
-  var _a;
-  return family.key === ((_a = unknownToken.family) == null ? void 0 : _a.key);
-}
-
-exports.AtomIOLogger = AtomIOLogger;
-exports.LOG_LEVELS = LOG_LEVELS;
-exports.Silo = Silo;
-exports.atom = atom;
-exports.atomFamily = atomFamily;
-exports.belongsTo = belongsTo;
-exports.disposeState = disposeState;
-exports.getState = getState;
-exports.isToken = isToken;
-exports.makeMolecule = makeMolecule;
-exports.makeRootMolecule = makeRootMolecule;
-exports.moleculeFamily = moleculeFamily;
-exports.redo = redo;
-exports.runTransaction = runTransaction;
-exports.selector = selector;
-exports.selectorFamily = selectorFamily;
-exports.setState = setState;
-exports.simpleLog = simpleLog;
-exports.simpleLogger = simpleLogger;
-exports.subscribe = subscribe;
-exports.timeline = timeline;
-exports.transaction = transaction;
-exports.undo = undo;

package/ephemeral/dist/index.cjs

@@ -1,11 +0,0 @@
-'use strict';
-
-var internal = require('atom.io/internal');
-
-// ephemeral/src/find-state.ts
-function findState(token, key) {
-  const state = internal.findInStore(token, key, internal.IMPLICIT.STORE);
-  return state;
-}
-
-exports.findState = findState;

package/eslint-plugin/dist/index.cjs

@@ -1,388 +0,0 @@
-'use strict';
-
-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)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// eslint-plugin/src/rules/index.ts
-var rules_exports = {};
-__export(rules_exports, {
-  explicitStateTypes: () => explicitStateTypes,
-  lifespan: () => lifespan,
-  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/walk.ts
-function walk(node, callback, depth = 0) {
-  callback(node, depth);
-  switch (node.type) {
-    case `FunctionDeclaration`:
-    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 `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/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) {
-    var _a;
-    const storeLifespan = (_a = context.options[0]) != null ? _a : `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 : void 0;
-        const methodCallee = node.callee.type === `MemberExpression` && node.callee.property.type === `Identifier` ? node.callee.property : void 0;
-        const callee = functionCallee != null ? functionCallee : methodCallee;
-        if (callee === void 0) {
-          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 : void 0;
-          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: {
-    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 == null ? void 0 : selectorLookupProperty.value;
-            if ((selectorLookup == null ? void 0 : selectorLookup.type) === `FunctionExpression` || (selectorLookup == null ? void 0 : 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 == null ? void 0 : selectorComputationProperty.value;
-          }
-        }
-        if ((selectorComputation == null ? void 0 : selectorComputation.type) === `FunctionExpression` || (selectorComputation == null ? void 0 : 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,
-    lifespan,
-    "synchronous-selector-dependencies": synchronousSelectorDependencies
-  }
-};
-
-exports.Rules = rules_exports;
-exports.default = src_default;

package/immortal/dist/index.cjs

@@ -1,14 +0,0 @@
-'use strict';
-
-var internal = require('atom.io/internal');
-
-// immortal/src/seek-state.ts
-function seekState(token, key) {
-  if (token.type === `molecule_family`) {
-    return internal.seekInStore(token, key, internal.IMPLICIT.STORE);
-  }
-  const state = internal.seekInStore(token, key, internal.IMPLICIT.STORE);
-  return state;
-}
-
-exports.seekState = seekState;