{"version":3,"sources":["webpack://@liferay/frontend-js-state-web/src/main/resources/META-INF/resources/State.ts","webpack://@liferay/frontend-js-state-web/src/main/resources/META-INF/resources/SubscriberMap.ts","webpack://@liferay/frontend-js-state-web/src/main/resources/META-INF/resources/deepFreeze.ts","webpack://@liferay/frontend-js-state-web/webpack/bootstrap","webpack://@liferay/frontend-js-state-web/src/main/resources/META-INF/resources/index.ts"],"names":["Object","defineProperty","exports","value","_SubscriberMap","_interopRequireDefault","__webpack_require__","_deepFreeze","obj","__esModule","default","ATOM","atoms","Map","dependencies","selectors","subscribers","values","warnings","readKey","Set","subscribeKey","writeKey","State","__internal__","debug","Array","from","[object Object]","clear","__unsafe__","key","has","console","warn","concat","JSON","stringify","add","atomOrSelector","get","read","Error","callback","subscribe","writeAtom","invalidated","directDependencies","selector","delete","push","this","_invalidateDependencies","error","info","name","toString","seen","path","index","indexOf","splice","cycle","map","join","getter","set","isAtom","readAtom","_readSelector","deriveValue","atom","readSelector","Liferay.State.SELECTOR","dispose","addCallback","previous","is","frozen","getCallbacks","_notify","invalidatedSelectors","hasOwnProperty","call","window","Liferay","_default","_defineProperty","enumerable","configurable","writable","_id","_subscribers","subscriberId","callbacks","deepFreeze","isArray","forEach","freeze","__webpack_module_cache__","moduleId","cachedModule","undefined","module","__webpack_modules__","_State"],"mappings":"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","sourcesContent":["Object.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nvar _SubscriberMap = _interopRequireDefault(require(\"./SubscriberMap\"));\n\nvar _deepFreeze = _interopRequireDefault(require(\"./deepFreeze\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/**\n * Copyright (c) 2000-present Liferay, Inc. All rights reserved.\n *\n * This library is free software; you can redistribute it and/or modify it under\n * the terms of the GNU Lesser General Public License as published by the Free\n * Software Foundation; either version 2.1 of the License, or (at your option)\n * any later version.\n *\n * This library is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more\n * details.\n */\n// In the future, these should be Symbol(); see:\n// https://github.com/microsoft/TypeScript/issues/37888\nconst ATOM = 'Liferay.State.ATOM';\nconst SELECTOR = 'Liferay.State.SELECTOR';\nconst atoms = new Map();\nconst dependencies = new Map();\nconst selectors = new Map();\nconst subscribers = new _SubscriberMap.default();\nconst values = new Map();\nconst warnings = {\n  readKey: new Set(),\n  subscribeKey: new Set(),\n  writeKey: new Set()\n};\nconst State = {\n  __internal__: {\n    debug: {\n      get atoms() {\n        return Array.from(atoms.values());\n      },\n\n      get selectors() {\n        return Array.from(selectors.values());\n      }\n\n    },\n\n    reset() {\n      atoms.clear();\n      dependencies.clear();\n      selectors.clear();\n      subscribers.clear();\n      values.clear();\n      warnings.readKey.clear();\n      warnings.subscribeKey.clear();\n      warnings.writeKey.clear();\n    }\n\n  },\n\n  /**\n   * Methods in the `__unsafe__` namespace are provided as an escape hatch to\n   * allow interacting with global state from places where it may not be\n   * practical or possible to obtain a reference to a concrete atom or\n   * selector (for example, from within JSPs). These methods all take a string\n   * key and use it to look up the corresponding atom or selector.\n   *\n   * This usage is considered unsafe because it bypasses the static type\n   * checking provided by the main API (`read()`, `write()` etc). Given that\n   * the integrity of global shared state largely depends on the values being\n   * of a predictable and correct type, you should use the `__unsafe__` API\n   * only as a last resort. Instead, consider moving legacy code out of JSPs\n   * and into places where it can fully participate in the module-loading\n   * system and thus access concrete atoms and selectors by importing them. At\n   * the same time, moving legacy code into React components provides access\n   * to the `useLiferayState()` hook and other conveniences.\n   */\n  __unsafe__: {\n    readKey(key) {\n      if (process.env.NODE_ENV === 'development') {\n        if (!warnings.readKey.has(key)) {\n          console.warn(\"Liferay.State.__unsafe__.readKey(): access via string key \".concat(JSON.stringify(key), \" is not type-safe; prefer read(), readAtom() or readSelector() instead\"));\n          warnings.readKey.add(key);\n        }\n      }\n\n      const atomOrSelector = atoms.get(key) || selectors.get(key);\n\n      if (atomOrSelector) {\n        return State.read(atomOrSelector);\n      } else {\n        throw new Error(\"Liferay.State.__unsafe__.readKey(): no atom or selector exists for key \".concat(JSON.stringify(key)));\n      }\n    },\n\n    subscribeKey(key, callback) {\n      if (process.env.NODE_ENV === 'development') {\n        if (!warnings.subscribeKey.has(key)) {\n          console.warn(\"Liferay.State.__unsafe__.subscribeWithKey(): access via string key \".concat(JSON.stringify(key), \" is not type-safe; prefer subscribe() instead\"));\n          warnings.subscribeKey.add(key);\n        }\n      }\n\n      const atomOrSelector = atoms.get(key) || selectors.get(key);\n\n      if (atomOrSelector) {\n        return State.subscribe(atomOrSelector, callback);\n      } else {\n        throw new Error(\"Liferay.State.__unsafe__.subscribeKey(): no atom or selector exists for key \".concat(JSON.stringify(key)));\n      }\n    },\n\n    writeKey(key, value) {\n      if (process.env.NODE_ENV === 'development') {\n        if (!warnings.writeKey.has(key)) {\n          console.warn(\"Liferay.State.__unsafe__.writeKey(): access via string key \".concat(JSON.stringify(key), \" is not type-safe; prefer write() or writeAtom() instead\"));\n          warnings.writeKey.add(key);\n        }\n      }\n\n      if (selectors.has(key)) {\n        throw new Error(\"Liferay.State.__unsafe__.writeKey(): expected atom but found selector for key \".concat(JSON.stringify(key)));\n      } else if (atoms.has(key)) {\n        State.writeAtom(atoms.get(key), value);\n      } else {\n        throw new Error(\"Liferay.State.__unsafe__.writeKey(): no atom exists for key \".concat(JSON.stringify(key)));\n      }\n    }\n\n  },\n\n  _invalidateDependencies(atomOrSelector, invalidated) {\n    const directDependencies = dependencies.get(atomOrSelector);\n\n    if (!directDependencies) {\n      return;\n    }\n\n    for (const selector of directDependencies) {\n      values.delete(selector);\n      invalidated.push(selector);\n\n      this._invalidateDependencies(selector, invalidated);\n    }\n  },\n\n  _notify(callback, value) {\n    try {\n      callback(value);\n    } catch (error) {\n      console.error(\"Liferay.State._notify(): caught error during subscriber notification: \".concat(error));\n\n      if (process.env.NODE_ENV === 'development') {\n        /* eslint-disable-next-line no-console */\n        console.info(\"Callback name: \".concat(callback.name || 'undefined', \"\\n\") + 'Callback body:\\n\\n' + \"\".concat(callback.toString(), \"\\n\\n\"));\n      }\n    }\n  },\n\n  _readSelector(selector, seen) {\n    if (seen.has(selector)) {\n      const path = Array.from(seen.values());\n      const index = path.indexOf(selector);\n      path.splice(0, index);\n      path.push(selector);\n      const cycle = path.map(({\n        key\n      }) => JSON.stringify(key)).join(' -> ');\n      throw new Error(\"Liferay.State.readSelector(): cycle detected: \".concat(cycle));\n    }\n\n    if (!values.has(selector)) {\n      const getter = atomOrSelector => {\n        if (!dependencies.has(atomOrSelector)) {\n          dependencies.set(atomOrSelector, new Set());\n        }\n\n        dependencies.get(atomOrSelector).add(selector);\n\n        if (isAtom(atomOrSelector)) {\n          return State.readAtom(atomOrSelector);\n        } else {\n          return State._readSelector(atomOrSelector, seen);\n        }\n      };\n\n      seen.add(selector);\n      const value = (0, _deepFreeze.default)(selector.deriveValue(getter));\n      seen.delete(selector);\n      values.set(selector, value);\n    }\n\n    return values.get(selector);\n  },\n\n  /**\n   * Register a unit of shared state called an \"atom\". Atoms have a unique\n   * string key, a type `T`, and a default value. Atoms themselves are\n   * immutable, but are each associated with a corresponding \"current\" value\n   * that can be read, updated, and observed.\n   *\n   * Given an atom, you can interact with the current value associated with it\n   * in these ways:\n   *\n   * - Read it with `read()` or `readAtom()`.\n   * - Update it with `write()` or `writeAtom()`.\n   * - Subscribe to be notified of changes with `subscribe()`.\n   * - In React components, the `useLiferayState()` hook does all the above.\n   */\n  atom(key, value) {\n    if (atoms.has(key)) {\n      if (process.env.NODE_ENV === 'production') {\n        // Unlike in development where there may be hot-reloading,\n        // re-registering (overwriting) is not considered ok.\n        throw new Error(\"Liferay.State.atom(): key \".concat(JSON.stringify(key), \" already taken\"));\n      }\n    }\n\n    if (selectors.has(key)) {\n      throw new Error(\"Liferay.State.atom(): key \".concat(JSON.stringify(key), \" already taken by a selector\"));\n    }\n\n    const atom = (0, _deepFreeze.default)({\n      [ATOM]: true,\n      default: value,\n      key\n    });\n    atoms.set(key, atom);\n    return atom;\n  },\n\n  /**\n   * Read the current value associated with the provided atom or selector.\n   *\n   * This is a convenience wrapper around `readAtom()` and `readSelector()`.\n   */\n  read(atomOrSelector) {\n    if (isAtom(atomOrSelector)) {\n      return State.readAtom(atomOrSelector);\n    } else {\n      return State.readSelector(atomOrSelector);\n    }\n  },\n\n  /**\n   * Read the current value associated with the provided atom.\n   */\n  readAtom(atom) {\n    if (values.has(atom)) {\n      return values.get(atom);\n    } else {\n      return atom.default;\n    }\n  },\n\n  /**\n   * Read the current value associated with the provided selector.\n   */\n  readSelector(selector) {\n    const seen = new Set();\n    return State._readSelector(selector, seen);\n  },\n\n  /**\n   * Register a shared unit of derived state called a \"selector\", identified\n   * by a unique string key. Selectors derive their values via a \"pure\"\n   * function that reads atoms and/or other selectors. Selectors form a\n   * dependency graph, which means that when upstream atoms or selectors\n   * change, the dependent selectors get automatically and efficiently\n   * recomputed.\n   *\n   * Given a selector, you can interact with the current value associated with\n   * it in these ways:\n   *\n   * - Read it with `read()` or `readSelector()`.\n   * - Subscribe to be notified of changes with `subscribe()`.\n   * - In React components, the `useLiferayState()` hook does all the above.\n   *\n   * Note that, unlike atoms, you cannot `write()` directly to a selector;\n   * instead, you update them by changing their upstream atoms, which causes\n   * the affected selectors to re-derive their updated values.\n   */\n  selector(key, deriveValue) {\n    if (selectors.has(key)) {\n      if (process.env.NODE_ENV === 'production') {\n        // In development where there may be hot-reloading,\n        // re-registering (overwriting) is considered ok.\n        throw new Error(\"Liferay.State.selector(): key \".concat(JSON.stringify(key), \" already taken\"));\n      }\n    }\n\n    if (atoms.has(key)) {\n      throw new Error(\"Liferay.State.selector(): key \".concat(JSON.stringify(key), \" already taken by an atom\"));\n    }\n\n    const selector = (0, _deepFreeze.default)({\n      [SELECTOR]: true,\n      deriveValue,\n      key\n    });\n    selectors.set(key, selector);\n    return selector;\n  },\n\n  /**\n   * Subscribe to be notified of changes to an atom or selector.\n   *\n   * The supplied `callback()` function will be invoked with the new value\n   * whenever it changes. To unsubscribe, use the `dispose()` function that is\n   * returned.\n   *\n   * In the context of a React component, the `useLiferayState()` hook can be\n   * used to observe and trigger state changes in a way that is analagous to\n   * the built-in `useState()` hook.\n   */\n  subscribe(atomOrSelector, callback) {\n    const dispose = subscribers.addCallback(atomOrSelector, callback);\n\n    if (!isAtom(atomOrSelector)) {\n      // Read once in order to pre-populate dependency graph.\n      State.readSelector(atomOrSelector);\n    }\n\n    return {\n      dispose\n    };\n  },\n\n  /**\n   * Attempt to update the value associated with the provided atom or\n   * selector.\n   *\n   * Note that this is just a convenience wrapper around `writeAtom()` that\n   * serves principally to streamline calls (for example, from the\n   * `useLiferayState()` hook), and in practice it is an error to attempt a\n   * direct update to a selector (instead, the upstream atoms that it depends\n   * on should be updated).\n   */\n  write(atomOrSelector, value) {\n    if (isAtom(atomOrSelector)) {\n      State.writeAtom(atomOrSelector, value);\n    } else {\n      throw new Error(\"Liferay.State.write(): expected atom but received selector with key \".concat(JSON.stringify(atomOrSelector.key)));\n    }\n  },\n\n  /**\n   * Update the value associated with the provided atom, notifying any\n   * downstream subscribers (of the atom itself, or selectors that depend on\n   * it).\n   */\n  writeAtom(atom, value) {\n    const previous = values.get(atom);\n\n    if (Object.is(value, previous)) {\n      return;\n    }\n\n    const frozen = (0, _deepFreeze.default)(value);\n    values.set(atom, frozen);\n\n    for (const callback of subscribers.getCallbacks(atom).values()) {\n      State._notify(callback, frozen);\n    }\n\n    const invalidatedSelectors = [];\n\n    this._invalidateDependencies(atom, invalidatedSelectors);\n\n    for (const selector of invalidatedSelectors) {\n      for (const callback of subscribers.getCallbacks(selector).values()) {\n        State._notify(callback, State.readSelector(selector));\n      }\n    }\n  }\n\n};\n\nfunction isAtom(value) {\n  return Object.hasOwnProperty.call(value, ATOM);\n}\n\nwindow.Liferay = window.Liferay || {};\n/**\n * Boilerplate to satisfy TypeScript and prevent: \"TS2669: Augmentations\n * for the global scope can only be directly nested in external modules or\n * ambient module declarations.\"\n */\n\nvar _default = State;\nexports.default = _default;","Object.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = void 0;\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/**\n * Copyright (c) 2000-present Liferay, Inc. All rights reserved.\n *\n * This library is free software; you can redistribute it and/or modify it under\n * the terms of the GNU Lesser General Public License as published by the Free\n * Software Foundation; either version 2.1 of the License, or (at your option)\n * any later version.\n *\n * This library is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more\n * details.\n */\n\n/**\n * `Map` wrapper for type safety. While a vanilla `Map` is totally adequate for\n * our needs in terms of implementation, at the type-system level the declared\n * type of `Map<K, V>` isn't expressive enough to capture what we want (which\n * would be something like the following -- sadly, not valid TypeScript -- where\n * \"T\" would be any arbitrary subtype of \"unknown\", and we don't care what the\n * concrete type is, only that it is the same within each key/value pair).\n */\nclass SubscriberMap {\n  constructor() {\n    _defineProperty(this, \"_id\", void 0);\n\n    _defineProperty(this, \"_subscribers\", void 0);\n\n    this._id = 0;\n    this._subscribers = new Map();\n  }\n\n  clear() {\n    this._subscribers.clear();\n  }\n\n  getCallbacks(atomOrSelector) {\n    if (!this._subscribers.has(atomOrSelector)) {\n      this._subscribers.set(atomOrSelector, new Map());\n    }\n\n    return this._subscribers.get(atomOrSelector);\n  }\n\n  addCallback(atomOrSelector, callback) {\n    const subscriberId = this._id++;\n    const callbacks = this.getCallbacks(atomOrSelector);\n    callbacks.set(subscriberId, callback);\n    return () => callbacks.delete(subscriberId);\n  }\n\n}\n\nexports.default = SubscriberMap;","Object.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.default = deepFreeze;\n\n/**\n * Copyright (c) 2000-present Liferay, Inc. All rights reserved.\n *\n * This library is free software; you can redistribute it and/or modify it under\n * the terms of the GNU Lesser General Public License as published by the Free\n * Software Foundation; either version 2.1 of the License, or (at your option)\n * any later version.\n *\n * This library is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\n * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more\n * details.\n */\nfunction deepFreeze(value) {\n  if (process.env.NODE_ENV === 'development') {\n    if (Array.isArray(value)) {\n      value.forEach(deepFreeze);\n    } else if (value && typeof value === 'object') {\n      Object.values(value).forEach(deepFreeze);\n    }\n\n    Object.freeze(value);\n  }\n\n  return value;\n}","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","Object.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nObject.defineProperty(exports, \"State\", {\n  enumerable: true,\n  get: function get() {\n    return _State.default;\n  }\n});\n\nvar _State = _interopRequireDefault(require(\"./State\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }"]}