@neynar/ui 0.3.1 → 0.5.0

package/dist/node_modules/reselect/dist/reselect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reselect.js","sources":["../../../../node_modules/reselect/dist/reselect.mjs"],"sourcesContent":["// src/devModeChecks/identityFunctionCheck.ts\nvar runIdentityFunctionCheck = (resultFunc, inputSelectorsResults, outputSelectorResult) => {\n  if (inputSelectorsResults.length === 1 && inputSelectorsResults[0] === outputSelectorResult) {\n    let isInputSameAsOutput = false;\n    try {\n      const emptyObject = {};\n      if (resultFunc(emptyObject) === emptyObject)\n        isInputSameAsOutput = true;\n    } catch {\n    }\n    if (isInputSameAsOutput) {\n      let stack = void 0;\n      try {\n        throw new Error();\n      } catch (e) {\n        ;\n        ({ stack } = e);\n      }\n      console.warn(\n        \"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.\",\n        { stack }\n      );\n    }\n  }\n};\n\n// src/devModeChecks/inputStabilityCheck.ts\nvar runInputStabilityCheck = (inputSelectorResultsObject, options, inputSelectorArgs) => {\n  const { memoize, memoizeOptions } = options;\n  const { inputSelectorResults, inputSelectorResultsCopy } = inputSelectorResultsObject;\n  const createAnEmptyObject = memoize(() => ({}), ...memoizeOptions);\n  const areInputSelectorResultsEqual = createAnEmptyObject.apply(null, inputSelectorResults) === createAnEmptyObject.apply(null, inputSelectorResultsCopy);\n  if (!areInputSelectorResultsEqual) {\n    let stack = void 0;\n    try {\n      throw new Error();\n    } catch (e) {\n      ;\n      ({ stack } = e);\n    }\n    console.warn(\n      \"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)`\",\n      {\n        arguments: inputSelectorArgs,\n        firstInputs: inputSelectorResults,\n        secondInputs: inputSelectorResultsCopy,\n        stack\n      }\n    );\n  }\n};\n\n// src/devModeChecks/setGlobalDevModeChecks.ts\nvar globalDevModeChecks = {\n  inputStabilityCheck: \"once\",\n  identityFunctionCheck: \"once\"\n};\nvar setGlobalDevModeChecks = (devModeChecks) => {\n  Object.assign(globalDevModeChecks, devModeChecks);\n};\n\n// src/utils.ts\nvar NOT_FOUND = /* @__PURE__ */ Symbol(\"NOT_FOUND\");\nfunction assertIsFunction(func, errorMessage = `expected a function, instead received ${typeof func}`) {\n  if (typeof func !== \"function\") {\n    throw new TypeError(errorMessage);\n  }\n}\nfunction assertIsObject(object, errorMessage = `expected an object, instead received ${typeof object}`) {\n  if (typeof object !== \"object\") {\n    throw new TypeError(errorMessage);\n  }\n}\nfunction assertIsArrayOfFunctions(array, errorMessage = `expected all items to be functions, instead received the following types: `) {\n  if (!array.every((item) => typeof item === \"function\")) {\n    const itemTypes = array.map(\n      (item) => typeof item === \"function\" ? `function ${item.name || \"unnamed\"}()` : typeof item\n    ).join(\", \");\n    throw new TypeError(`${errorMessage}[${itemTypes}]`);\n  }\n}\nvar ensureIsArray = (item) => {\n  return Array.isArray(item) ? item : [item];\n};\nfunction getDependencies(createSelectorArgs) {\n  const dependencies = Array.isArray(createSelectorArgs[0]) ? createSelectorArgs[0] : createSelectorArgs;\n  assertIsArrayOfFunctions(\n    dependencies,\n    `createSelector expects all input-selectors to be functions, but received the following types: `\n  );\n  return dependencies;\n}\nfunction collectInputSelectorResults(dependencies, inputSelectorArgs) {\n  const inputSelectorResults = [];\n  const { length } = dependencies;\n  for (let i = 0; i < length; i++) {\n    inputSelectorResults.push(dependencies[i].apply(null, inputSelectorArgs));\n  }\n  return inputSelectorResults;\n}\nvar getDevModeChecksExecutionInfo = (firstRun, devModeChecks) => {\n  const { identityFunctionCheck, inputStabilityCheck } = {\n    ...globalDevModeChecks,\n    ...devModeChecks\n  };\n  return {\n    identityFunctionCheck: {\n      shouldRun: identityFunctionCheck === \"always\" || identityFunctionCheck === \"once\" && firstRun,\n      run: runIdentityFunctionCheck\n    },\n    inputStabilityCheck: {\n      shouldRun: inputStabilityCheck === \"always\" || inputStabilityCheck === \"once\" && firstRun,\n      run: runInputStabilityCheck\n    }\n  };\n};\n\n// src/autotrackMemoize/autotracking.ts\nvar $REVISION = 0;\nvar CURRENT_TRACKER = null;\nvar Cell = class {\n  revision = $REVISION;\n  _value;\n  _lastValue;\n  _isEqual = tripleEq;\n  constructor(initialValue, isEqual = tripleEq) {\n    this._value = this._lastValue = initialValue;\n    this._isEqual = isEqual;\n  }\n  // Whenever a storage value is read, it'll add itself to the current tracker if\n  // one exists, entangling its state with that cache.\n  get value() {\n    CURRENT_TRACKER?.add(this);\n    return this._value;\n  }\n  // Whenever a storage value is updated, we bump the global revision clock,\n  // assign the revision for this storage to the new value, _and_ we schedule a\n  // rerender. This is important, and it's what makes autotracking  _pull_\n  // based. We don't actively tell the caches which depend on the storage that\n  // anything has happened. Instead, we recompute the caches when needed.\n  set value(newValue) {\n    if (this.value === newValue)\n      return;\n    this._value = newValue;\n    this.revision = ++$REVISION;\n  }\n};\nfunction tripleEq(a, b) {\n  return a === b;\n}\nvar TrackingCache = class {\n  _cachedValue;\n  _cachedRevision = -1;\n  _deps = [];\n  hits = 0;\n  fn;\n  constructor(fn) {\n    this.fn = fn;\n  }\n  clear() {\n    this._cachedValue = void 0;\n    this._cachedRevision = -1;\n    this._deps = [];\n    this.hits = 0;\n  }\n  get value() {\n    if (this.revision > this._cachedRevision) {\n      const { fn } = this;\n      const currentTracker = /* @__PURE__ */ new Set();\n      const prevTracker = CURRENT_TRACKER;\n      CURRENT_TRACKER = currentTracker;\n      this._cachedValue = fn();\n      CURRENT_TRACKER = prevTracker;\n      this.hits++;\n      this._deps = Array.from(currentTracker);\n      this._cachedRevision = this.revision;\n    }\n    CURRENT_TRACKER?.add(this);\n    return this._cachedValue;\n  }\n  get revision() {\n    return Math.max(...this._deps.map((d) => d.revision), 0);\n  }\n};\nfunction getValue(cell) {\n  if (!(cell instanceof Cell)) {\n    console.warn(\"Not a valid cell! \", cell);\n  }\n  return cell.value;\n}\nfunction setValue(storage, value) {\n  if (!(storage instanceof Cell)) {\n    throw new TypeError(\n      \"setValue must be passed a tracked store created with `createStorage`.\"\n    );\n  }\n  storage.value = storage._lastValue = value;\n}\nfunction createCell(initialValue, isEqual = tripleEq) {\n  return new Cell(initialValue, isEqual);\n}\nfunction createCache(fn) {\n  assertIsFunction(\n    fn,\n    \"the first parameter to `createCache` must be a function\"\n  );\n  return new TrackingCache(fn);\n}\n\n// src/autotrackMemoize/tracking.ts\nvar neverEq = (a, b) => false;\nfunction createTag() {\n  return createCell(null, neverEq);\n}\nfunction dirtyTag(tag, value) {\n  setValue(tag, value);\n}\nvar consumeCollection = (node) => {\n  let tag = node.collectionTag;\n  if (tag === null) {\n    tag = node.collectionTag = createTag();\n  }\n  getValue(tag);\n};\nvar dirtyCollection = (node) => {\n  const tag = node.collectionTag;\n  if (tag !== null) {\n    dirtyTag(tag, null);\n  }\n};\n\n// src/autotrackMemoize/proxy.ts\nvar REDUX_PROXY_LABEL = Symbol();\nvar nextId = 0;\nvar proto = Object.getPrototypeOf({});\nvar ObjectTreeNode = class {\n  constructor(value) {\n    this.value = value;\n    this.value = value;\n    this.tag.value = value;\n  }\n  proxy = new Proxy(this, objectProxyHandler);\n  tag = createTag();\n  tags = {};\n  children = {};\n  collectionTag = null;\n  id = nextId++;\n};\nvar objectProxyHandler = {\n  get(node, key) {\n    function calculateResult() {\n      const { value } = node;\n      const childValue = Reflect.get(value, key);\n      if (typeof key === \"symbol\") {\n        return childValue;\n      }\n      if (key in proto) {\n        return childValue;\n      }\n      if (typeof childValue === \"object\" && childValue !== null) {\n        let childNode = node.children[key];\n        if (childNode === void 0) {\n          childNode = node.children[key] = createNode(childValue);\n        }\n        if (childNode.tag) {\n          getValue(childNode.tag);\n        }\n        return childNode.proxy;\n      } else {\n        let tag = node.tags[key];\n        if (tag === void 0) {\n          tag = node.tags[key] = createTag();\n          tag.value = childValue;\n        }\n        getValue(tag);\n        return childValue;\n      }\n    }\n    const res = calculateResult();\n    return res;\n  },\n  ownKeys(node) {\n    consumeCollection(node);\n    return Reflect.ownKeys(node.value);\n  },\n  getOwnPropertyDescriptor(node, prop) {\n    return Reflect.getOwnPropertyDescriptor(node.value, prop);\n  },\n  has(node, prop) {\n    return Reflect.has(node.value, prop);\n  }\n};\nvar ArrayTreeNode = class {\n  constructor(value) {\n    this.value = value;\n    this.value = value;\n    this.tag.value = value;\n  }\n  proxy = new Proxy([this], arrayProxyHandler);\n  tag = createTag();\n  tags = {};\n  children = {};\n  collectionTag = null;\n  id = nextId++;\n};\nvar arrayProxyHandler = {\n  get([node], key) {\n    if (key === \"length\") {\n      consumeCollection(node);\n    }\n    return objectProxyHandler.get(node, key);\n  },\n  ownKeys([node]) {\n    return objectProxyHandler.ownKeys(node);\n  },\n  getOwnPropertyDescriptor([node], prop) {\n    return objectProxyHandler.getOwnPropertyDescriptor(node, prop);\n  },\n  has([node], prop) {\n    return objectProxyHandler.has(node, prop);\n  }\n};\nfunction createNode(value) {\n  if (Array.isArray(value)) {\n    return new ArrayTreeNode(value);\n  }\n  return new ObjectTreeNode(value);\n}\nfunction updateNode(node, newValue) {\n  const { value, tags, children } = node;\n  node.value = newValue;\n  if (Array.isArray(value) && Array.isArray(newValue) && value.length !== newValue.length) {\n    dirtyCollection(node);\n  } else {\n    if (value !== newValue) {\n      let oldKeysSize = 0;\n      let newKeysSize = 0;\n      let anyKeysAdded = false;\n      for (const _key in value) {\n        oldKeysSize++;\n      }\n      for (const key in newValue) {\n        newKeysSize++;\n        if (!(key in value)) {\n          anyKeysAdded = true;\n          break;\n        }\n      }\n      const isDifferent = anyKeysAdded || oldKeysSize !== newKeysSize;\n      if (isDifferent) {\n        dirtyCollection(node);\n      }\n    }\n  }\n  for (const key in tags) {\n    const childValue = value[key];\n    const newChildValue = newValue[key];\n    if (childValue !== newChildValue) {\n      dirtyCollection(node);\n      dirtyTag(tags[key], newChildValue);\n    }\n    if (typeof newChildValue === \"object\" && newChildValue !== null) {\n      delete tags[key];\n    }\n  }\n  for (const key in children) {\n    const childNode = children[key];\n    const newChildValue = newValue[key];\n    const childValue = childNode.value;\n    if (childValue === newChildValue) {\n      continue;\n    } else if (typeof newChildValue === \"object\" && newChildValue !== null) {\n      updateNode(childNode, newChildValue);\n    } else {\n      deleteNode(childNode);\n      delete children[key];\n    }\n  }\n}\nfunction deleteNode(node) {\n  if (node.tag) {\n    dirtyTag(node.tag, null);\n  }\n  dirtyCollection(node);\n  for (const key in node.tags) {\n    dirtyTag(node.tags[key], null);\n  }\n  for (const key in node.children) {\n    deleteNode(node.children[key]);\n  }\n}\n\n// src/lruMemoize.ts\nfunction createSingletonCache(equals) {\n  let entry;\n  return {\n    get(key) {\n      if (entry && equals(entry.key, key)) {\n        return entry.value;\n      }\n      return NOT_FOUND;\n    },\n    put(key, value) {\n      entry = { key, value };\n    },\n    getEntries() {\n      return entry ? [entry] : [];\n    },\n    clear() {\n      entry = void 0;\n    }\n  };\n}\nfunction createLruCache(maxSize, equals) {\n  let entries = [];\n  function get(key) {\n    const cacheIndex = entries.findIndex((entry) => equals(key, entry.key));\n    if (cacheIndex > -1) {\n      const entry = entries[cacheIndex];\n      if (cacheIndex > 0) {\n        entries.splice(cacheIndex, 1);\n        entries.unshift(entry);\n      }\n      return entry.value;\n    }\n    return NOT_FOUND;\n  }\n  function put(key, value) {\n    if (get(key) === NOT_FOUND) {\n      entries.unshift({ key, value });\n      if (entries.length > maxSize) {\n        entries.pop();\n      }\n    }\n  }\n  function getEntries() {\n    return entries;\n  }\n  function clear() {\n    entries = [];\n  }\n  return { get, put, getEntries, clear };\n}\nvar referenceEqualityCheck = (a, b) => a === b;\nfunction createCacheKeyComparator(equalityCheck) {\n  return function areArgumentsShallowlyEqual(prev, next) {\n    if (prev === null || next === null || prev.length !== next.length) {\n      return false;\n    }\n    const { length } = prev;\n    for (let i = 0; i < length; i++) {\n      if (!equalityCheck(prev[i], next[i])) {\n        return false;\n      }\n    }\n    return true;\n  };\n}\nfunction lruMemoize(func, equalityCheckOrOptions) {\n  const providedOptions = typeof equalityCheckOrOptions === \"object\" ? equalityCheckOrOptions : { equalityCheck: equalityCheckOrOptions };\n  const {\n    equalityCheck = referenceEqualityCheck,\n    maxSize = 1,\n    resultEqualityCheck\n  } = providedOptions;\n  const comparator = createCacheKeyComparator(equalityCheck);\n  let resultsCount = 0;\n  const cache = maxSize <= 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator);\n  function memoized() {\n    let value = cache.get(arguments);\n    if (value === NOT_FOUND) {\n      value = func.apply(null, arguments);\n      resultsCount++;\n      if (resultEqualityCheck) {\n        const entries = cache.getEntries();\n        const matchingEntry = entries.find(\n          (entry) => resultEqualityCheck(entry.value, value)\n        );\n        if (matchingEntry) {\n          value = matchingEntry.value;\n          resultsCount !== 0 && resultsCount--;\n        }\n      }\n      cache.put(arguments, value);\n    }\n    return value;\n  }\n  memoized.clearCache = () => {\n    cache.clear();\n    memoized.resetResultsCount();\n  };\n  memoized.resultsCount = () => resultsCount;\n  memoized.resetResultsCount = () => {\n    resultsCount = 0;\n  };\n  return memoized;\n}\n\n// src/autotrackMemoize/autotrackMemoize.ts\nfunction autotrackMemoize(func) {\n  const node = createNode(\n    []\n  );\n  let lastArgs = null;\n  const shallowEqual = createCacheKeyComparator(referenceEqualityCheck);\n  const cache = createCache(() => {\n    const res = func.apply(null, node.proxy);\n    return res;\n  });\n  function memoized() {\n    if (!shallowEqual(lastArgs, arguments)) {\n      updateNode(node, arguments);\n      lastArgs = arguments;\n    }\n    return cache.value;\n  }\n  memoized.clearCache = () => {\n    return cache.clear();\n  };\n  return memoized;\n}\n\n// src/weakMapMemoize.ts\nvar StrongRef = class {\n  constructor(value) {\n    this.value = value;\n  }\n  deref() {\n    return this.value;\n  }\n};\nvar Ref = typeof WeakRef !== \"undefined\" ? WeakRef : StrongRef;\nvar UNTERMINATED = 0;\nvar TERMINATED = 1;\nfunction createCacheNode() {\n  return {\n    s: UNTERMINATED,\n    v: void 0,\n    o: null,\n    p: null\n  };\n}\nfunction weakMapMemoize(func, options = {}) {\n  let fnNode = createCacheNode();\n  const { resultEqualityCheck } = options;\n  let lastResult;\n  let resultsCount = 0;\n  function memoized() {\n    let cacheNode = fnNode;\n    const { length } = arguments;\n    for (let i = 0, l = length; i < l; i++) {\n      const arg = arguments[i];\n      if (typeof arg === \"function\" || typeof arg === \"object\" && arg !== null) {\n        let objectCache = cacheNode.o;\n        if (objectCache === null) {\n          cacheNode.o = objectCache = /* @__PURE__ */ new WeakMap();\n        }\n        const objectNode = objectCache.get(arg);\n        if (objectNode === void 0) {\n          cacheNode = createCacheNode();\n          objectCache.set(arg, cacheNode);\n        } else {\n          cacheNode = objectNode;\n        }\n      } else {\n        let primitiveCache = cacheNode.p;\n        if (primitiveCache === null) {\n          cacheNode.p = primitiveCache = /* @__PURE__ */ new Map();\n        }\n        const primitiveNode = primitiveCache.get(arg);\n        if (primitiveNode === void 0) {\n          cacheNode = createCacheNode();\n          primitiveCache.set(arg, cacheNode);\n        } else {\n          cacheNode = primitiveNode;\n        }\n      }\n    }\n    const terminatedNode = cacheNode;\n    let result;\n    if (cacheNode.s === TERMINATED) {\n      result = cacheNode.v;\n    } else {\n      result = func.apply(null, arguments);\n      resultsCount++;\n      if (resultEqualityCheck) {\n        const lastResultValue = lastResult?.deref?.() ?? lastResult;\n        if (lastResultValue != null && resultEqualityCheck(lastResultValue, result)) {\n          result = lastResultValue;\n          resultsCount !== 0 && resultsCount--;\n        }\n        const needsWeakRef = typeof result === \"object\" && result !== null || typeof result === \"function\";\n        lastResult = needsWeakRef ? new Ref(result) : result;\n      }\n    }\n    terminatedNode.s = TERMINATED;\n    terminatedNode.v = result;\n    return result;\n  }\n  memoized.clearCache = () => {\n    fnNode = createCacheNode();\n    memoized.resetResultsCount();\n  };\n  memoized.resultsCount = () => resultsCount;\n  memoized.resetResultsCount = () => {\n    resultsCount = 0;\n  };\n  return memoized;\n}\n\n// src/createSelectorCreator.ts\nfunction createSelectorCreator(memoizeOrOptions, ...memoizeOptionsFromArgs) {\n  const createSelectorCreatorOptions = typeof memoizeOrOptions === \"function\" ? {\n    memoize: memoizeOrOptions,\n    memoizeOptions: memoizeOptionsFromArgs\n  } : memoizeOrOptions;\n  const createSelector2 = (...createSelectorArgs) => {\n    let recomputations = 0;\n    let dependencyRecomputations = 0;\n    let lastResult;\n    let directlyPassedOptions = {};\n    let resultFunc = createSelectorArgs.pop();\n    if (typeof resultFunc === \"object\") {\n      directlyPassedOptions = resultFunc;\n      resultFunc = createSelectorArgs.pop();\n    }\n    assertIsFunction(\n      resultFunc,\n      `createSelector expects an output function after the inputs, but received: [${typeof resultFunc}]`\n    );\n    const combinedOptions = {\n      ...createSelectorCreatorOptions,\n      ...directlyPassedOptions\n    };\n    const {\n      memoize,\n      memoizeOptions = [],\n      argsMemoize = weakMapMemoize,\n      argsMemoizeOptions = [],\n      devModeChecks = {}\n    } = combinedOptions;\n    const finalMemoizeOptions = ensureIsArray(memoizeOptions);\n    const finalArgsMemoizeOptions = ensureIsArray(argsMemoizeOptions);\n    const dependencies = getDependencies(createSelectorArgs);\n    const memoizedResultFunc = memoize(function recomputationWrapper() {\n      recomputations++;\n      return resultFunc.apply(\n        null,\n        arguments\n      );\n    }, ...finalMemoizeOptions);\n    let firstRun = true;\n    const selector = argsMemoize(function dependenciesChecker() {\n      dependencyRecomputations++;\n      const inputSelectorResults = collectInputSelectorResults(\n        dependencies,\n        arguments\n      );\n      lastResult = memoizedResultFunc.apply(null, inputSelectorResults);\n      if (process.env.NODE_ENV !== \"production\") {\n        const { identityFunctionCheck, inputStabilityCheck } = getDevModeChecksExecutionInfo(firstRun, devModeChecks);\n        if (identityFunctionCheck.shouldRun) {\n          identityFunctionCheck.run(\n            resultFunc,\n            inputSelectorResults,\n            lastResult\n          );\n        }\n        if (inputStabilityCheck.shouldRun) {\n          const inputSelectorResultsCopy = collectInputSelectorResults(\n            dependencies,\n            arguments\n          );\n          inputStabilityCheck.run(\n            { inputSelectorResults, inputSelectorResultsCopy },\n            { memoize, memoizeOptions: finalMemoizeOptions },\n            arguments\n          );\n        }\n        if (firstRun)\n          firstRun = false;\n      }\n      return lastResult;\n    }, ...finalArgsMemoizeOptions);\n    return Object.assign(selector, {\n      resultFunc,\n      memoizedResultFunc,\n      dependencies,\n      dependencyRecomputations: () => dependencyRecomputations,\n      resetDependencyRecomputations: () => {\n        dependencyRecomputations = 0;\n      },\n      lastResult: () => lastResult,\n      recomputations: () => recomputations,\n      resetRecomputations: () => {\n        recomputations = 0;\n      },\n      memoize,\n      argsMemoize\n    });\n  };\n  Object.assign(createSelector2, {\n    withTypes: () => createSelector2\n  });\n  return createSelector2;\n}\nvar createSelector = /* @__PURE__ */ createSelectorCreator(weakMapMemoize);\n\n// src/createStructuredSelector.ts\nvar createStructuredSelector = Object.assign(\n  (inputSelectorsObject, selectorCreator = createSelector) => {\n    assertIsObject(\n      inputSelectorsObject,\n      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof inputSelectorsObject}`\n    );\n    const inputSelectorKeys = Object.keys(inputSelectorsObject);\n    const dependencies = inputSelectorKeys.map(\n      (key) => inputSelectorsObject[key]\n    );\n    const structuredSelector = selectorCreator(\n      dependencies,\n      (...inputSelectorResults) => {\n        return inputSelectorResults.reduce((composition, value, index) => {\n          composition[inputSelectorKeys[index]] = value;\n          return composition;\n        }, {});\n      }\n    );\n    return structuredSelector;\n  },\n  { withTypes: () => createStructuredSelector }\n);\nexport {\n  createSelector,\n  createSelectorCreator,\n  createStructuredSelector,\n  lruMemoize,\n  referenceEqualityCheck,\n  setGlobalDevModeChecks,\n  autotrackMemoize as unstable_autotrackMemoize,\n  weakMapMemoize\n};\n//# sourceMappingURL=reselect.mjs.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}