nolo-cli 0.33.0-alpha.9 → 0.34.0-alpha.3

package/{chunk-X664KVEV.js → chunk-HHBXCRJS.js}

@@ -2,16 +2,16 @@ import {
   getAllServers,
   getIsDesktopApp,
   isAbortError
-} from "./chunk-WJSW43QZ.js";
+} from "./chunk-L3JWI7WX.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
 import {
   asOptionalPositiveFiniteNumber
 } from "./chunk-U6VC4MU4.js";
-import {
-  isRecord
-} from "./chunk-KUG52IAP.js";
 import {
   API_ENDPOINTS,
   SERVERS,
@@ -28,104 +28,27 @@ import {
 } from "./chunk-G3SUCT4W.js";
 
 // node_modules/reselect/dist/reselect.mjs
-var runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {
-  if (inputSelectorsResults.length === 1 && inputSelectorsResults[0] === outputSelectorResult) {
-    let isInputSameAsOutput = false;
-    try {
-      const emptyObject = {};
-      if (resultFunc(emptyObject) === emptyObject) isInputSameAsOutput = true;
-    } catch {
-    }
-    if (isInputSameAsOutput) {
-      let stack = void 0;
-      try {
-        throw new Error();
-      } catch (e) {
-        ;
-        ({ stack } = e);
-      }
-      console.warn(
-        "The result function returned its own inputs without modification. e.g\n`createSelector([state => state.todos], todos => todos)`\nThis could lead to inefficient memoization and unnecessary re-renders.\nEnsure transformation logic is in the result function, and extraction logic is in the input selectors.",
-        { stack }
-      );
-    }
-  }
-};
-var runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {
-  const { memoize, memoizeOptions } = options;
-  const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;
-  const createAnEmptyObject = memoize(() => ({}), ...memoizeOptions);
-  const areInputSelectorResultsEqual = createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy);
-  if (!areInputSelectorResultsEqual) {
-    let stack = void 0;
-    try {
-      throw new Error();
-    } catch (e) {
-      ;
-      ({ stack } = e);
-    }
-    console.warn(
-      "An input selector returned a different result when passed same arguments.\nThis means your output selector will likely run more frequently than intended.\nAvoid returning a new reference inside your input selector, e.g.\n`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)`",
-      {
-        arguments: inputSelectorArgs,
-        firstInputs: inputSelectorResults,
-        secondInputs: inputSelectorResultsCopy,
-        stack
-      }
-    );
-  }
+var CACHE_SIZE_CHECK_THRESHOLD = 1e3;
+var runCacheSizeCheck = (cacheSize, funcName) => {
+  let stack = void 0;
+  try {
+    throw new Error();
+  } catch (e) {
+    ;
+    ({ stack } = e);
+  }
+  console.warn(
+    `A function memoized with weakMapMemoize${funcName ? ` (\`${funcName}\`)` : ""} has seen over ${cacheSize} distinct values for the same primitive argument position.
+Results keyed by primitive arguments are held strongly and are only released by \`clearCache()\`, so this cache will keep growing for as long as the function keeps seeing new values.
+If it is called with ever-changing primitives (ids, offsets, timestamps), pass the \`maxSize\` option to bound the cache, switch to \`lruMemoize\`, or call \`.clearCache()\` at a suitable point.
+See https://reselect.js.org/api/development-only-checks#cachesizecheck for details.`,
+    { stack }
+  );
 };
 var globalDevModeChecks = {
   inputStabilityCheck: "once",
-  identityFunctionCheck: "once"
-};
-function assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {
-  if (typeof func !== "function") {
-    throw new TypeError(errorMessage);
-  }
-}
-function assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {
-  if (!array.every((item) => typeof item === "function")) {
-    const itemTypes = array.map(
-      (item) => typeof item === "function" ? `function ${item.name || "unnamed"}()` : typeof item
-    ).join(", ");
-    throw new TypeError(`${errorMessage}[${itemTypes}]`);
-  }
-}
-var ensureIsArray = (item) => {
-  return Array.isArray(item) ? item : [item];
-};
-function getDependencies(createSelectorArgs) {
-  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;
-  assertIsArrayOfFunctions(
-    dependencies,
-    `createSelector expects all input-selectors to be functions, but received the following types: `
-  );
-  return dependencies;
-}
-function collectInputSelectorResults(dependencies, inputSelectorArgs) {
-  const inputSelectorResults = [];
-  const { length } = dependencies;
-  for (let i = 0; i < length; i++) {
-    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));
-  }
-  return inputSelectorResults;
-}
-var getDevModeChecksExecutionInfo = (firstRun, devModeChecks) => {
-  const { identityFunctionCheck, inputStabilityCheck } = {
-    ...globalDevModeChecks,
-    ...devModeChecks
-  };
-  return {
-    identityFunctionCheck: {
-      shouldRun: identityFunctionCheck === "always" || identityFunctionCheck === "once" && firstRun,
-      run: runIdentityFunctionCheck
-    },
-    inputStabilityCheck: {
-      shouldRun: inputStabilityCheck === "always" || inputStabilityCheck === "once" && firstRun,
-      run: runInputStabilityCheck
-    }
-  };
+  identityFunctionCheck: "once",
+  cacheSizeCheck: "once"
 };
 var StrongRef = class {
   constructor(value) {
@@ -155,9 +78,25 @@ function maybeDeref(r) {
 }
 function weakMapMemoize(func, options = {}) {
   let fnNode = createCacheNode();
-  const { resultEqualityCheck } = options;
+  const { resultEqualityCheck, maxSize } = options;
+  const useGenerations = maxSize !== void 0;
+  if (useGenerations && (!Number.isInteger(maxSize) || maxSize < 1)) {
+    throw new TypeError(
+      `maxSize must be a positive integer, received: ${maxSize}`
+    );
+  }
+  let prevNode = null;
+  let insertionCount = 0;
   let lastResult;
   let resultsCount = 0;
+  let hasWarnedAboutCacheSize = false;
+  function maybeFlipGenerations() {
+    if (insertionCount >= maxSize) {
+      prevNode = fnNode;
+      fnNode = createCacheNode();
+      insertionCount = 0;
+    }
+  }
   function memoized() {
     let cacheNode = fnNode;
     const { length } = arguments;
@@ -184,35 +123,77 @@ function weakMapMemoize(func, options = {}) {
         if (primitiveNode === void 0) {
           cacheNode = createCacheNode();
           primitiveCache.set(arg, cacheNode);
+          insertionCount++;
+          if (process.env.NODE_ENV !== "production") {
+            if (primitiveCache.size > CACHE_SIZE_CHECK_THRESHOLD) {
+              const { cacheSizeCheck } = globalDevModeChecks;
+              if (cacheSizeCheck === "always" || cacheSizeCheck === "once" && !hasWarnedAboutCacheSize) {
+                hasWarnedAboutCacheSize = true;
+                runCacheSizeCheck(primitiveCache.size, func.name);
+              }
+            }
+          }
         } else {
           cacheNode = primitiveNode;
         }
       }
     }
-    const terminatedNode = cacheNode;
-    let result;
     if (cacheNode.s === TERMINATED) {
-      result = cacheNode.v;
-    } else {
-      result = func.apply(null, arguments);
-      resultsCount++;
-      if (resultEqualityCheck) {
-        const lastResultValue = maybeDeref(lastResult);
-        if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {
-          result = lastResultValue;
-          resultsCount !== 0 && resultsCount--;
+      return cacheNode.v;
+    }
+    if (prevNode !== null) {
+      let prevCacheNode = prevNode;
+      for (let i = 0, l = length; i < l; i++) {
+        const arg = arguments[i];
+        let next;
+        if (typeof arg === "function" || typeof arg === "object" && arg !== null) {
+          const prevObjectCache = prevCacheNode.o;
+          next = prevObjectCache !== null ? prevObjectCache.get(arg) : void 0;
+        } else {
+          const prevPrimitiveCache = prevCacheNode.p;
+          next = prevPrimitiveCache !== null ? prevPrimitiveCache.get(arg) : void 0;
+        }
+        if (next === void 0) {
+          prevCacheNode = null;
+          break;
         }
-        const needsWeakRef = typeof result === "object" && result !== null || typeof result === "function";
-        lastResult = needsWeakRef ? /* @__PURE__ */ new Ref(result) : result;
+        prevCacheNode = next;
+      }
+      if (prevCacheNode !== null && prevCacheNode.s === TERMINATED) {
+        const promotedNode = cacheNode;
+        promotedNode.s = TERMINATED;
+        promotedNode.v = prevCacheNode.v;
+        maybeFlipGenerations();
+        return prevCacheNode.v;
       }
     }
+    const terminatedNode = cacheNode;
+    let result = func.apply(null, arguments);
+    resultsCount++;
+    if (resultEqualityCheck) {
+      const lastResultValue = maybeDeref(lastResult);
+      if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {
+        result = lastResultValue;
+        resultsCount !== 0 && resultsCount--;
+      }
+      const needsWeakRef = typeof result === "object" && result !== null || typeof result === "function";
+      lastResult = needsWeakRef ? /* @__PURE__ */ new Ref(result) : result;
+    }
     terminatedNode.s = TERMINATED;
     terminatedNode.v = result;
+    if (useGenerations) {
+      maybeFlipGenerations();
+    }
     return result;
   }
   memoized.clearCache = () => {
     fnNode = createCacheNode();
+    prevNode = null;
+    insertionCount = 0;
     memoized.resetResultsCount();
+    if (process.env.NODE_ENV !== "production") {
+      hasWarnedAboutCacheSize = false;
+    }
   };
   memoized.resultsCount = () => resultsCount;
   memoized.resetResultsCount = () => {
@@ -220,6 +201,98 @@ function weakMapMemoize(func, options = {}) {
   };
   return memoized;
 }
+var runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {
+  if (inputSelectorsResults.length === 1 && inputSelectorsResults[0] === outputSelectorResult) {
+    let isInputSameAsOutput = false;
+    try {
+      const emptyObject = {};
+      if (resultFunc(emptyObject) === emptyObject) isInputSameAsOutput = true;
+    } catch {
+    }
+    if (isInputSameAsOutput) {
+      let stack = void 0;
+      try {
+        throw new Error();
+      } catch (e) {
+        ;
+        ({ stack } = e);
+      }
+      console.warn(
+        "The result function returned its own inputs without modification. e.g\n`createSelector([state => state.todos], todos => todos)`\nThis could lead to inefficient memoization and unnecessary re-renders.\nEnsure transformation logic is in the result function, and extraction logic is in the input selectors.",
+        { stack }
+      );
+    }
+  }
+};
+var withoutResultEqualityCheck = (option) => {
+  if (option === null || typeof option !== "object" || !("resultEqualityCheck" in option)) {
+    return option;
+  }
+  const optionCopy = { ...option };
+  delete optionCopy.resultEqualityCheck;
+  return optionCopy;
+};
+var runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {
+  const { memoize, memoizeOptions } = options;
+  const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;
+  const probeMemoizeOptions = [];
+  const { length } = memoizeOptions;
+  for (let i = 0; i < length; i++) {
+    probeMemoizeOptions.push(withoutResultEqualityCheck(memoizeOptions[i]));
+  }
+  const createAnEmptyObject = memoize(() => ({}), ...probeMemoizeOptions);
+  const areInputSelectorResultsEqual = createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy);
+  if (!areInputSelectorResultsEqual) {
+    let stack = void 0;
+    try {
+      throw new Error();
+    } catch (e) {
+      ;
+      ({ stack } = e);
+    }
+    console.warn(
+      "An input selector returned a different result when passed same arguments.\nThis means your output selector will likely run more frequently than intended.\nAvoid returning a new reference inside your input selector, e.g.\n`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)`",
+      {
+        arguments: inputSelectorArgs,
+        firstInputs: inputSelectorResults,
+        secondInputs: inputSelectorResultsCopy,
+        stack
+      }
+    );
+  }
+};
+function assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {
+  if (typeof func !== "function") {
+    throw new TypeError(errorMessage);
+  }
+}
+function assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {
+  if (!array.every((item) => typeof item === "function")) {
+    const itemTypes = array.map(
+      (item) => typeof item === "function" ? `function ${item.name || "unnamed"}()` : typeof item
+    ).join(", ");
+    throw new TypeError(`${errorMessage}[${itemTypes}]`);
+  }
+}
+var ensureIsArray = (item) => {
+  return Array.isArray(item) ? item : [item];
+};
+function getDependencies(createSelectorArgs) {
+  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;
+  assertIsArrayOfFunctions(
+    dependencies,
+    `createSelector expects all input-selectors to be functions, but received the following types: `
+  );
+  return dependencies;
+}
+function collectInputSelectorResults(dependencies, inputSelectorArgs) {
+  const inputSelectorResults = [];
+  const { length } = dependencies;
+  for (let i = 0; i < length; i++) {
+    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));
+  }
+  return inputSelectorResults;
+}
 function createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {
   const createSelectorCreatorOptions = typeof memoizeOrOptions === "function" ? {
     memoize: memoizeOrOptions,
@@ -262,27 +335,35 @@ function createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {
     let firstRun = true;
     const selector = argsMemoize(function dependenciesChecker() {
       dependencyRecomputations++;
-      const inputSelectorResults = collectInputSelectorResults(
-        dependencies,
-        arguments
-      );
+      const { length } = dependencies;
+      const inputSelectorResults = new Array(length);
+      for (let i = 0; i < length; i++) {
+        inputSelectorResults[i] = dependencies[i].apply(null, arguments);
+      }
       lastResult = memoizedResultFunc.apply(null, inputSelectorResults);
       if (process.env.NODE_ENV !== "production") {
-        const { devModeChecks = {} } = combinedOptions;
-        const { identityFunctionCheck, inputStabilityCheck } = getDevModeChecksExecutionInfo(firstRun, devModeChecks);
-        if (identityFunctionCheck.shouldRun) {
-          identityFunctionCheck.run(
+        const { devModeChecks } = combinedOptions;
+        const identityFunctionCheck = devModeChecks !== void 0 && Object.prototype.hasOwnProperty.call(
+          devModeChecks,
+          "identityFunctionCheck"
+        ) ? devModeChecks.identityFunctionCheck : globalDevModeChecks.identityFunctionCheck;
+        const inputStabilityCheck = devModeChecks !== void 0 && Object.prototype.hasOwnProperty.call(
+          devModeChecks,
+          "inputStabilityCheck"
+        ) ? devModeChecks.inputStabilityCheck : globalDevModeChecks.inputStabilityCheck;
+        if (identityFunctionCheck === "always" || identityFunctionCheck === "once" && firstRun) {
+          runIdentityFunctionCheck(
             resultFunc,
             inputSelectorResults,
             lastResult
           );
         }
-        if (inputStabilityCheck.shouldRun) {
+        if (inputStabilityCheck === "always" || inputStabilityCheck === "once" && firstRun) {
           const inputSelectorResultsCopy = collectInputSelectorResults(
             dependencies,
             arguments
           );
-          inputStabilityCheck.run(
+          runInputStabilityCheck(
             { inputSelectorResults, inputSelectorResultsCopy },
             { memoize, memoizeOptions: finalMemoizeOptions },
             arguments