@lls/store 24.1.57-3bf4faf5 → 24.1.57-4e182f7c

package/README.md

@@ -3,6 +3,12 @@
 Represents lls models
 
 Centralizes
+
 - model types
 - selectors
 
+Only handles
+
+- entities
+- auth
+

package/lib/index.js

@@ -1,26 +1,802 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// <define:import.meta>
+var init_define_import_meta = __esm({
+  "<define:import.meta>"() {
+  }
+});
+
+// ../../node_modules/.pnpm/reselect@4.1.8/node_modules/reselect/lib/defaultMemoize.js
+var require_defaultMemoize = __commonJS({
+  "../../node_modules/.pnpm/reselect@4.1.8/node_modules/reselect/lib/defaultMemoize.js"(exports) {
+    "use strict";
+    init_define_import_meta();
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.createCacheKeyComparator = createCacheKeyComparator;
+    exports.defaultEqualityCheck = void 0;
+    exports.defaultMemoize = defaultMemoize;
+    var NOT_FOUND = "NOT_FOUND";
+    function createSingletonCache(equals) {
+      var entry;
+      return {
+        get: function get(key) {
+          if (entry && equals(entry.key, key)) {
+            return entry.value;
+          }
+          return NOT_FOUND;
+        },
+        put: function put(key, value) {
+          entry = {
+            key,
+            value
+          };
+        },
+        getEntries: function getEntries() {
+          return entry ? [entry] : [];
+        },
+        clear: function clear() {
+          entry = void 0;
+        }
+      };
+    }
+    function createLruCache(maxSize, equals) {
+      var entries = [];
+      function get(key) {
+        var cacheIndex = entries.findIndex(function(entry2) {
+          return equals(key, entry2.key);
+        });
+        if (cacheIndex > -1) {
+          var entry = entries[cacheIndex];
+          if (cacheIndex > 0) {
+            entries.splice(cacheIndex, 1);
+            entries.unshift(entry);
+          }
+          return entry.value;
+        }
+        return NOT_FOUND;
+      }
+      function put(key, value) {
+        if (get(key) === NOT_FOUND) {
+          entries.unshift({
+            key,
+            value
+          });
+          if (entries.length > maxSize) {
+            entries.pop();
+          }
+        }
+      }
+      function getEntries() {
+        return entries;
+      }
+      function clear() {
+        entries = [];
+      }
+      return {
+        get,
+        put,
+        getEntries,
+        clear
+      };
+    }
+    var defaultEqualityCheck = function defaultEqualityCheck2(a, b) {
+      return a === b;
+    };
+    exports.defaultEqualityCheck = defaultEqualityCheck;
+    function createCacheKeyComparator(equalityCheck) {
+      return function areArgumentsShallowlyEqual(prev, next) {
+        if (prev === null || next === null || prev.length !== next.length) {
+          return false;
+        }
+        var length = prev.length;
+        for (var i = 0; i < length; i++) {
+          if (!equalityCheck(prev[i], next[i])) {
+            return false;
+          }
+        }
+        return true;
+      };
+    }
+    function defaultMemoize(func, equalityCheckOrOptions) {
+      var providedOptions = typeof equalityCheckOrOptions === "object" ? equalityCheckOrOptions : {
+        equalityCheck: equalityCheckOrOptions
+      };
+      var _providedOptions$equa = providedOptions.equalityCheck, equalityCheck = _providedOptions$equa === void 0 ? defaultEqualityCheck : _providedOptions$equa, _providedOptions$maxS = providedOptions.maxSize, maxSize = _providedOptions$maxS === void 0 ? 1 : _providedOptions$maxS, resultEqualityCheck = providedOptions.resultEqualityCheck;
+      var comparator = createCacheKeyComparator(equalityCheck);
+      var cache = maxSize === 1 ? createSingletonCache(comparator) : createLruCache(maxSize, comparator);
+      function memoized() {
+        var value = cache.get(arguments);
+        if (value === NOT_FOUND) {
+          value = func.apply(null, arguments);
+          if (resultEqualityCheck) {
+            var entries = cache.getEntries();
+            var matchingEntry = entries.find(function(entry) {
+              return resultEqualityCheck(entry.value, value);
+            });
+            if (matchingEntry) {
+              value = matchingEntry.value;
+            }
+          }
+          cache.put(arguments, value);
+        }
+        return value;
+      }
+      memoized.clearCache = function() {
+        return cache.clear();
+      };
+      return memoized;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/reselect@4.1.8/node_modules/reselect/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/reselect@4.1.8/node_modules/reselect/lib/index.js"(exports) {
+    "use strict";
+    init_define_import_meta();
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.createSelector = void 0;
+    exports.createSelectorCreator = createSelectorCreator;
+    exports.createStructuredSelector = void 0;
+    Object.defineProperty(exports, "defaultEqualityCheck", {
+      enumerable: true,
+      get: function get() {
+        return _defaultMemoize.defaultEqualityCheck;
+      }
+    });
+    Object.defineProperty(exports, "defaultMemoize", {
+      enumerable: true,
+      get: function get() {
+        return _defaultMemoize.defaultMemoize;
+      }
+    });
+    var _defaultMemoize = require_defaultMemoize();
+    function getDependencies(funcs) {
+      var dependencies = Array.isArray(funcs[0]) ? funcs[0] : funcs;
+      if (!dependencies.every(function(dep) {
+        return typeof dep === "function";
+      })) {
+        var dependencyTypes = dependencies.map(function(dep) {
+          return typeof dep === "function" ? "function " + (dep.name || "unnamed") + "()" : typeof dep;
+        }).join(", ");
+        throw new Error("createSelector expects all input-selectors to be functions, but received the following types: [" + dependencyTypes + "]");
+      }
+      return dependencies;
+    }
+    function createSelectorCreator(memoize) {
+      for (var _len = arguments.length, memoizeOptionsFromArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        memoizeOptionsFromArgs[_key - 1] = arguments[_key];
+      }
+      var createSelector3 = function createSelector4() {
+        for (var _len2 = arguments.length, funcs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          funcs[_key2] = arguments[_key2];
+        }
+        var _recomputations = 0;
+        var _lastResult;
+        var directlyPassedOptions = {
+          memoizeOptions: void 0
+        };
+        var resultFunc = funcs.pop();
+        if (typeof resultFunc === "object") {
+          directlyPassedOptions = resultFunc;
+          resultFunc = funcs.pop();
+        }
+        if (typeof resultFunc !== "function") {
+          throw new Error("createSelector expects an output function after the inputs, but received: [" + typeof resultFunc + "]");
+        }
+        var _directlyPassedOption = directlyPassedOptions, _directlyPassedOption2 = _directlyPassedOption.memoizeOptions, memoizeOptions = _directlyPassedOption2 === void 0 ? memoizeOptionsFromArgs : _directlyPassedOption2;
+        var finalMemoizeOptions = Array.isArray(memoizeOptions) ? memoizeOptions : [memoizeOptions];
+        var dependencies = getDependencies(funcs);
+        var memoizedResultFunc = memoize.apply(void 0, [function recomputationWrapper() {
+          _recomputations++;
+          return resultFunc.apply(null, arguments);
+        }].concat(finalMemoizeOptions));
+        var selector = memoize(function dependenciesChecker() {
+          var params = [];
+          var length = dependencies.length;
+          for (var i = 0; i < length; i++) {
+            params.push(dependencies[i].apply(null, arguments));
+          }
+          _lastResult = memoizedResultFunc.apply(null, params);
+          return _lastResult;
+        });
+        Object.assign(selector, {
+          resultFunc,
+          memoizedResultFunc,
+          dependencies,
+          lastResult: function lastResult() {
+            return _lastResult;
+          },
+          recomputations: function recomputations() {
+            return _recomputations;
+          },
+          resetRecomputations: function resetRecomputations() {
+            return _recomputations = 0;
+          }
+        });
+        return selector;
+      };
+      return createSelector3;
+    }
+    var createSelector2 = /* @__PURE__ */ createSelectorCreator(_defaultMemoize.defaultMemoize);
+    exports.createSelector = createSelector2;
+    var createStructuredSelector = function createStructuredSelector2(selectors, selectorCreator) {
+      if (selectorCreator === void 0) {
+        selectorCreator = createSelector2;
+      }
+      if (typeof selectors !== "object") {
+        throw new Error("createStructuredSelector expects first argument to be an object " + ("where each property is a selector, instead received a " + typeof selectors));
+      }
+      var objectKeys = Object.keys(selectors);
+      var resultSelector = selectorCreator(
+        // @ts-ignore
+        objectKeys.map(function(key) {
+          return selectors[key];
+        }),
+        function() {
+          for (var _len3 = arguments.length, values = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+            values[_key3] = arguments[_key3];
+          }
+          return values.reduce(function(composition, value, index) {
+            composition[objectKeys[index]] = value;
+            return composition;
+          }, {});
+        }
+      );
+      return resultSelector;
+    };
+    exports.createStructuredSelector = createStructuredSelector;
+  }
+});
+
+// ../../node_modules/.pnpm/normalizr@3.6.2/node_modules/normalizr/dist/normalizr.js
+var require_normalizr = __commonJS({
+  "../../node_modules/.pnpm/normalizr@3.6.2/node_modules/normalizr/dist/normalizr.js"(exports) {
+    "use strict";
+    init_define_import_meta();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      return Constructor;
+    }
+    function _extends() {
+      _extends = Object.assign || function(target) {
+        for (var i = 1; i < arguments.length; i++) {
+          var source = arguments[i];
+          for (var key in source) {
+            if (Object.prototype.hasOwnProperty.call(source, key)) {
+              target[key] = source[key];
+            }
+          }
+        }
+        return target;
+      };
+      return _extends.apply(this, arguments);
+    }
+    function _inheritsLoose(subClass, superClass) {
+      subClass.prototype = Object.create(superClass.prototype);
+      subClass.prototype.constructor = subClass;
+      subClass.__proto__ = superClass;
+    }
+    function isImmutable(object) {
+      return !!(object && typeof object.hasOwnProperty === "function" && (object.hasOwnProperty("__ownerID") || // Immutable.Map
+      object._map && object._map.hasOwnProperty("__ownerID")));
+    }
+    function denormalizeImmutable(schema3, input, unvisit) {
+      return Object.keys(schema3).reduce(function(object, key) {
+        var stringKey = "" + key;
+        if (object.has(stringKey)) {
+          return object.set(stringKey, unvisit(object.get(stringKey), schema3[stringKey]));
+        } else {
+          return object;
+        }
+      }, input);
+    }
+    var getDefaultGetId = function getDefaultGetId2(idAttribute) {
+      return function(input) {
+        return isImmutable(input) ? input.get(idAttribute) : input[idAttribute];
+      };
+    };
+    var EntitySchema = /* @__PURE__ */ function() {
+      function EntitySchema2(key, definition, options) {
+        if (definition === void 0) {
+          definition = {};
+        }
+        if (options === void 0) {
+          options = {};
+        }
+        if (!key || typeof key !== "string") {
+          throw new Error("Expected a string key for Entity, but found " + key + ".");
+        }
+        var _options = options, _options$idAttribute = _options.idAttribute, idAttribute = _options$idAttribute === void 0 ? "id" : _options$idAttribute, _options$mergeStrateg = _options.mergeStrategy, mergeStrategy = _options$mergeStrateg === void 0 ? function(entityA, entityB) {
+          return _extends({}, entityA, entityB);
+        } : _options$mergeStrateg, _options$processStrat = _options.processStrategy, processStrategy = _options$processStrat === void 0 ? function(input) {
+          return _extends({}, input);
+        } : _options$processStrat, _options$fallbackStra = _options.fallbackStrategy, fallbackStrategy = _options$fallbackStra === void 0 ? function(key2, schema3) {
+          return void 0;
+        } : _options$fallbackStra;
+        this._key = key;
+        this._getId = typeof idAttribute === "function" ? idAttribute : getDefaultGetId(idAttribute);
+        this._idAttribute = idAttribute;
+        this._mergeStrategy = mergeStrategy;
+        this._processStrategy = processStrategy;
+        this._fallbackStrategy = fallbackStrategy;
+        this.define(definition);
+      }
+      var _proto = EntitySchema2.prototype;
+      _proto.define = function define2(definition) {
+        this.schema = Object.keys(definition).reduce(function(entitySchema, key) {
+          var _extends2;
+          var schema3 = definition[key];
+          return _extends({}, entitySchema, (_extends2 = {}, _extends2[key] = schema3, _extends2));
+        }, this.schema || {});
+      };
+      _proto.getId = function getId(input, parent, key) {
+        return this._getId(input, parent, key);
+      };
+      _proto.merge = function merge(entityA, entityB) {
+        return this._mergeStrategy(entityA, entityB);
+      };
+      _proto.fallback = function fallback(id, schema3) {
+        return this._fallbackStrategy(id, schema3);
+      };
+      _proto.normalize = function normalize3(input, parent, key, visit2, addEntity, visitedEntities) {
+        var _this = this;
+        var id = this.getId(input, parent, key);
+        var entityType = this.key;
+        if (!(entityType in visitedEntities)) {
+          visitedEntities[entityType] = {};
+        }
+        if (!(id in visitedEntities[entityType])) {
+          visitedEntities[entityType][id] = [];
+        }
+        if (visitedEntities[entityType][id].some(function(entity) {
+          return entity === input;
+        })) {
+          return id;
+        }
+        visitedEntities[entityType][id].push(input);
+        var processedEntity = this._processStrategy(input, parent, key);
+        Object.keys(this.schema).forEach(function(key2) {
+          if (processedEntity.hasOwnProperty(key2) && typeof processedEntity[key2] === "object") {
+            var schema3 = _this.schema[key2];
+            var resolvedSchema = typeof schema3 === "function" ? schema3(input) : schema3;
+            processedEntity[key2] = visit2(processedEntity[key2], processedEntity, key2, resolvedSchema, addEntity, visitedEntities);
+          }
+        });
+        addEntity(this, processedEntity, input, parent, key);
+        return id;
+      };
+      _proto.denormalize = function denormalize2(entity, unvisit) {
+        var _this2 = this;
+        if (isImmutable(entity)) {
+          return denormalizeImmutable(this.schema, entity, unvisit);
+        }
+        Object.keys(this.schema).forEach(function(key) {
+          if (entity.hasOwnProperty(key)) {
+            var schema3 = _this2.schema[key];
+            entity[key] = unvisit(entity[key], schema3);
+          }
+        });
+        return entity;
+      };
+      _createClass(EntitySchema2, [{
+        key: "key",
+        get: function get() {
+          return this._key;
+        }
+      }, {
+        key: "idAttribute",
+        get: function get() {
+          return this._idAttribute;
+        }
+      }]);
+      return EntitySchema2;
+    }();
+    var PolymorphicSchema = /* @__PURE__ */ function() {
+      function PolymorphicSchema2(definition, schemaAttribute) {
+        if (schemaAttribute) {
+          this._schemaAttribute = typeof schemaAttribute === "string" ? function(input) {
+            return input[schemaAttribute];
+          } : schemaAttribute;
+        }
+        this.define(definition);
+      }
+      var _proto = PolymorphicSchema2.prototype;
+      _proto.define = function define2(definition) {
+        this.schema = definition;
+      };
+      _proto.getSchemaAttribute = function getSchemaAttribute(input, parent, key) {
+        return !this.isSingleSchema && this._schemaAttribute(input, parent, key);
+      };
+      _proto.inferSchema = function inferSchema(input, parent, key) {
+        if (this.isSingleSchema) {
+          return this.schema;
+        }
+        var attr = this.getSchemaAttribute(input, parent, key);
+        return this.schema[attr];
+      };
+      _proto.normalizeValue = function normalizeValue(value, parent, key, visit2, addEntity, visitedEntities) {
+        var schema3 = this.inferSchema(value, parent, key);
+        if (!schema3) {
+          return value;
+        }
+        var normalizedValue = visit2(value, parent, key, schema3, addEntity, visitedEntities);
+        return this.isSingleSchema || normalizedValue === void 0 || normalizedValue === null ? normalizedValue : {
+          id: normalizedValue,
+          schema: this.getSchemaAttribute(value, parent, key)
+        };
+      };
+      _proto.denormalizeValue = function denormalizeValue(value, unvisit) {
+        var schemaKey = isImmutable(value) ? value.get("schema") : value.schema;
+        if (!this.isSingleSchema && !schemaKey) {
+          return value;
+        }
+        var id = this.isSingleSchema ? void 0 : isImmutable(value) ? value.get("id") : value.id;
+        var schema3 = this.isSingleSchema ? this.schema : this.schema[schemaKey];
+        return unvisit(id || value, schema3);
+      };
+      _createClass(PolymorphicSchema2, [{
+        key: "isSingleSchema",
+        get: function get() {
+          return !this._schemaAttribute;
+        }
+      }]);
+      return PolymorphicSchema2;
+    }();
+    var UnionSchema = /* @__PURE__ */ function(_PolymorphicSchema) {
+      _inheritsLoose(UnionSchema2, _PolymorphicSchema);
+      function UnionSchema2(definition, schemaAttribute) {
+        if (!schemaAttribute) {
+          throw new Error('Expected option "schemaAttribute" not found on UnionSchema.');
+        }
+        return _PolymorphicSchema.call(this, definition, schemaAttribute) || this;
+      }
+      var _proto = UnionSchema2.prototype;
+      _proto.normalize = function normalize3(input, parent, key, visit2, addEntity, visitedEntities) {
+        return this.normalizeValue(input, parent, key, visit2, addEntity, visitedEntities);
+      };
+      _proto.denormalize = function denormalize2(input, unvisit) {
+        return this.denormalizeValue(input, unvisit);
+      };
+      return UnionSchema2;
+    }(PolymorphicSchema);
+    var ValuesSchema = /* @__PURE__ */ function(_PolymorphicSchema) {
+      _inheritsLoose(ValuesSchema2, _PolymorphicSchema);
+      function ValuesSchema2() {
+        return _PolymorphicSchema.apply(this, arguments) || this;
+      }
+      var _proto = ValuesSchema2.prototype;
+      _proto.normalize = function normalize3(input, parent, key, visit2, addEntity, visitedEntities) {
+        var _this = this;
+        return Object.keys(input).reduce(function(output, key2, index) {
+          var _extends2;
+          var value = input[key2];
+          return value !== void 0 && value !== null ? _extends({}, output, (_extends2 = {}, _extends2[key2] = _this.normalizeValue(value, input, key2, visit2, addEntity, visitedEntities), _extends2)) : output;
+        }, {});
+      };
+      _proto.denormalize = function denormalize2(input, unvisit) {
+        var _this2 = this;
+        return Object.keys(input).reduce(function(output, key) {
+          var _extends3;
+          var entityOrId = input[key];
+          return _extends({}, output, (_extends3 = {}, _extends3[key] = _this2.denormalizeValue(entityOrId, unvisit), _extends3));
+        }, {});
+      };
+      return ValuesSchema2;
+    }(PolymorphicSchema);
+    var validateSchema = function validateSchema2(definition) {
+      var isArray = Array.isArray(definition);
+      if (isArray && definition.length > 1) {
+        throw new Error("Expected schema definition to be a single schema, but found " + definition.length + ".");
+      }
+      return definition[0];
+    };
+    var getValues = function getValues2(input) {
+      return Array.isArray(input) ? input : Object.keys(input).map(function(key) {
+        return input[key];
+      });
+    };
+    var normalize2 = function normalize3(schema3, input, parent, key, visit2, addEntity, visitedEntities) {
+      schema3 = validateSchema(schema3);
+      var values = getValues(input);
+      return values.map(function(value, index) {
+        return visit2(value, parent, key, schema3, addEntity, visitedEntities);
+      });
+    };
+    var denormalize = function denormalize2(schema3, input, unvisit) {
+      schema3 = validateSchema(schema3);
+      return input && input.map ? input.map(function(entityOrId) {
+        return unvisit(entityOrId, schema3);
+      }) : input;
+    };
+    var ArraySchema = /* @__PURE__ */ function(_PolymorphicSchema) {
+      _inheritsLoose(ArraySchema2, _PolymorphicSchema);
+      function ArraySchema2() {
+        return _PolymorphicSchema.apply(this, arguments) || this;
+      }
+      var _proto = ArraySchema2.prototype;
+      _proto.normalize = function normalize3(input, parent, key, visit2, addEntity, visitedEntities) {
+        var _this = this;
+        var values = getValues(input);
+        return values.map(function(value, index) {
+          return _this.normalizeValue(value, parent, key, visit2, addEntity, visitedEntities);
+        }).filter(function(value) {
+          return value !== void 0 && value !== null;
+        });
+      };
+      _proto.denormalize = function denormalize2(input, unvisit) {
+        var _this2 = this;
+        return input && input.map ? input.map(function(value) {
+          return _this2.denormalizeValue(value, unvisit);
+        }) : input;
+      };
+      return ArraySchema2;
+    }(PolymorphicSchema);
+    var _normalize = function normalize3(schema3, input, parent, key, visit2, addEntity, visitedEntities) {
+      var object = _extends({}, input);
+      Object.keys(schema3).forEach(function(key2) {
+        var localSchema = schema3[key2];
+        var resolvedLocalSchema = typeof localSchema === "function" ? localSchema(input) : localSchema;
+        var value = visit2(input[key2], input, key2, resolvedLocalSchema, addEntity, visitedEntities);
+        if (value === void 0 || value === null) {
+          delete object[key2];
+        } else {
+          object[key2] = value;
+        }
+      });
+      return object;
+    };
+    var _denormalize = function denormalize2(schema3, input, unvisit) {
+      if (isImmutable(input)) {
+        return denormalizeImmutable(schema3, input, unvisit);
+      }
+      var object = _extends({}, input);
+      Object.keys(schema3).forEach(function(key) {
+        if (object[key] != null) {
+          object[key] = unvisit(object[key], schema3[key]);
+        }
+      });
+      return object;
+    };
+    var ObjectSchema = /* @__PURE__ */ function() {
+      function ObjectSchema2(definition) {
+        this.define(definition);
+      }
+      var _proto = ObjectSchema2.prototype;
+      _proto.define = function define2(definition) {
+        this.schema = Object.keys(definition).reduce(function(entitySchema, key) {
+          var _extends2;
+          var schema3 = definition[key];
+          return _extends({}, entitySchema, (_extends2 = {}, _extends2[key] = schema3, _extends2));
+        }, this.schema || {});
+      };
+      _proto.normalize = function normalize3() {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        return _normalize.apply(void 0, [this.schema].concat(args));
+      };
+      _proto.denormalize = function denormalize2() {
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        return _denormalize.apply(void 0, [this.schema].concat(args));
+      };
+      return ObjectSchema2;
+    }();
+    var visit = function visit2(value, parent, key, schema3, addEntity, visitedEntities) {
+      if (typeof value !== "object" || !value) {
+        return value;
+      }
+      if (typeof schema3 === "object" && (!schema3.normalize || typeof schema3.normalize !== "function")) {
+        var method = Array.isArray(schema3) ? normalize2 : _normalize;
+        return method(schema3, value, parent, key, visit2, addEntity, visitedEntities);
+      }
+      return schema3.normalize(value, parent, key, visit2, addEntity, visitedEntities);
+    };
+    var addEntities = function addEntities2(entities2) {
+      return function(schema3, processedEntity, value, parent, key) {
+        var schemaKey = schema3.key;
+        var id = schema3.getId(value, parent, key);
+        if (!(schemaKey in entities2)) {
+          entities2[schemaKey] = {};
+        }
+        var existingEntity = entities2[schemaKey][id];
+        if (existingEntity) {
+          entities2[schemaKey][id] = schema3.merge(existingEntity, processedEntity);
+        } else {
+          entities2[schemaKey][id] = processedEntity;
+        }
+      };
+    };
+    var schema2 = {
+      Array: ArraySchema,
+      Entity: EntitySchema,
+      Object: ObjectSchema,
+      Union: UnionSchema,
+      Values: ValuesSchema
+    };
+    var normalize$1 = function normalize3(input, schema3) {
+      if (!input || typeof input !== "object") {
+        throw new Error('Unexpected input given to normalize. Expected type to be "object", found "' + (input === null ? "null" : typeof input) + '".');
+      }
+      var entities2 = {};
+      var addEntity = addEntities(entities2);
+      var visitedEntities = {};
+      var result = visit(input, input, null, schema3, addEntity, visitedEntities);
+      return {
+        entities: entities2,
+        result
+      };
+    };
+    var unvisitEntity = function unvisitEntity2(id, schema3, unvisit, getEntity, cache) {
+      var entity = getEntity(id, schema3);
+      if (entity === void 0 && schema3 instanceof EntitySchema) {
+        entity = schema3.fallback(id, schema3);
+      }
+      if (typeof entity !== "object" || entity === null) {
+        return entity;
+      }
+      if (!cache[schema3.key]) {
+        cache[schema3.key] = {};
+      }
+      if (!cache[schema3.key][id]) {
+        var entityCopy = isImmutable(entity) ? entity : _extends({}, entity);
+        cache[schema3.key][id] = entityCopy;
+        cache[schema3.key][id] = schema3.denormalize(entityCopy, unvisit);
+      }
+      return cache[schema3.key][id];
+    };
+    var getUnvisit = function getUnvisit2(entities2) {
+      var cache = {};
+      var getEntity = getEntities(entities2);
+      return function unvisit(input, schema3) {
+        if (typeof schema3 === "object" && (!schema3.denormalize || typeof schema3.denormalize !== "function")) {
+          var method = Array.isArray(schema3) ? denormalize : _denormalize;
+          return method(schema3, input, unvisit);
+        }
+        if (input === void 0 || input === null) {
+          return input;
+        }
+        if (schema3 instanceof EntitySchema) {
+          return unvisitEntity(input, schema3, unvisit, getEntity, cache);
+        }
+        return schema3.denormalize(input, unvisit);
+      };
+    };
+    var getEntities = function getEntities2(entities2) {
+      var isImmutable$1 = isImmutable(entities2);
+      return function(entityOrId, schema3) {
+        var schemaKey = schema3.key;
+        if (typeof entityOrId === "object") {
+          return entityOrId;
+        }
+        if (isImmutable$1) {
+          return entities2.getIn([schemaKey, entityOrId.toString()]);
+        }
+        return entities2[schemaKey] && entities2[schemaKey][entityOrId];
+      };
+    };
+    var denormalize$1 = function denormalize2(input, schema3, entities2) {
+      if (typeof input !== "undefined") {
+        return getUnvisit(entities2)(input, schema3);
+      }
+    };
+    exports.denormalize = denormalize$1;
+    exports.normalize = normalize$1;
+    exports.schema = schema2;
+  }
+});
+
+// src/index.ts
+init_define_import_meta();
+
 // src/selectors/school.ts
-import {
-  createSearchSelector,
-  filterEntitiesSimpleFieldByValues,
-  makeGetAllEntities,
-  makeGetEntityById
-} from "@lls/utils";
+init_define_import_meta();
+import { filterEntitiesSimpleFieldByValues } from "@lls/utils";
+import _2 from "lodash/fp.js";
+
+// src/selectors/crud.ts
+init_define_import_meta();
+import { createSearchSelector, makeGetAllEntities, makeGetEntityById } from "@lls/utils";
 import _ from "lodash/fp.js";
-var getSchools = makeGetAllEntities("schools");
-var getSchool = makeGetEntityById("schools");
-var searchSchools = createSearchSelector(
-  getSchools,
-  (_state, params) => params,
-  (schools, { ids }) => {
-    return _.flow(filterEntitiesSimpleFieldByValues("id", ids))(schools);
-  }
+var crud = (entityName, { search: search3 }) => {
+  const getElements = makeGetAllEntities(entityName);
+  const makeSearchElements = () => createSearchSelector(
+    getElements,
+    (_state, params) => params,
+    (elements, params) => search3(params)(elements)
+  );
+  const methodName = _.capitalize(entityName);
+  const getElementById = makeGetEntityById(entityName);
+  const back = {
+    [`get${methodName}`]: getElements,
+    [`search${methodName}`]: makeSearchElements(),
+    [`get${methodName.replace(/s$/, "")}`]: getElementById,
+    [`makeSearch${methodName}`]: makeSearchElements
+  };
+  return back;
+};
+
+// src/selectors/school.ts
+var search = ({ ids }) => _2.flow(filterEntitiesSimpleFieldByValues("id", ids));
+var { getSchools, getSchool, searchSchools, makeSearchSchools } = crud("schools", {
+  search
+});
+
+// src/selectors/user.ts
+init_define_import_meta();
+var import_reselect = __toESM(require_lib(), 1);
+import { filterEntitiesArrayFieldByValues, filterEntitiesSimpleFieldByValues as filterEntitiesSimpleFieldByValues2 } from "@lls/utils";
+import _4 from "lodash/fp.js";
+
+// src/selectors/auth.ts
+init_define_import_meta();
+import _3 from "lodash/fp.js";
+var getAuth = _3.get("auth");
+var getIsLogged = _3.flow(_3.get("auth.id"), _3.negate(_3.isNil));
+var getToken = _3.get("auth.token");
+
+// src/selectors/user.ts
+var search2 = ({ ids, schoolIds }) => _4.flow(filterEntitiesArrayFieldByValues("schools", schoolIds), filterEntitiesSimpleFieldByValues2("id", ids));
+var { getUsers, getUser, searchUsers, makeSearchUsers } = crud("users", {
+  search: search2
+});
+var getCurrentUser = (0, import_reselect.createSelector)(
+  getAuth,
+  getUsers,
+  (auth2, users) => users?.find((user2) => user2?.id === auth2?.id)
 );
 
 // src/reducers/entities.ts
+init_define_import_meta();
 import { makeReducer } from "@lls/utils";
-import _2 from "lodash/fp.js";
+import _5 from "lodash/fp.js";
 
-// ../core/src/actions/index.ts
+// src/actions/index.ts
+init_define_import_meta();
 import { makeActionCreator } from "@lls/utils";
 var actionTypes = {
   DELETE_ENTITY: "DELETE_ENTITY",
@@ -28,24 +804,7 @@ var actionTypes = {
   SET_ENTITY: "SET_ENTITY",
   SET_ENTITIES: "SET_ENTITIES",
   RESET_AUTH: "RESET_AUTH",
-  SET_AUTH: "SET_AUTH",
-  SET_LOADING_SCREEN: "SET_LOADING_SCREEN",
-  SET_MODAL: "SET_MODAL",
-  ADD_NOTIFICATION: "ADD_NOTIFICATION",
-  REMOVE_NOTIFICATION: "REMOVE_NOTIFICATION",
-  SET_SHOWN_CONTEXTUAL_ACTIONS: "SET_SHOW_CONTEXTUAL_ACTIONS",
-  SET_IS_DRAWER_OPEN: "SET_IS_DRAWER_OPEN",
-  SET_DRAWER_EXPANDED_ID: "SET_DRAWER_EXPANDED_ID",
-  SET_IS_OPEN_SAVE_MODAL: "SET_IS_OPEN_SAVE_MODAL",
-  SET_IS_VIEWER_READY: "SET_IS_VIEWER_READY",
-  SET_CURRENT_TOUR_ID: "SET_CURRENT_TOUR_ID",
-  SET_CURRENT_TOUR_STEP: "SET_CURRENT_TOUR_STEP",
-  RESET_TOUR: "RESET_TOUR",
-  SET_IS_TOUR_PANEL_OPEN: "SET_IS_TOUR_PANEL_OPEN",
-  SET_TOUR_PANEL_MODE: "SET_TOUR_PANEL_MODE",
-  SET_IS_STUDENT_VIEW_ACTIVATED: "SET_IS_STUDENT_VIEW_ACTIVATED",
-  SET_SCENARIO_ID: "SET_SCENARIO_ID",
-  SET_SSR_FAKE_PAGE_ID: "SET_SSR_FAKE_PAGE_ID"
+  SET_AUTH: "SET_AUTH"
 };
 var deleteEntity = makeActionCreator(actionTypes.DELETE_ENTITY);
 var updateEntity = makeActionCreator(actionTypes.UPDATE_ENTITY);
@@ -53,44 +812,27 @@ var setEntity = makeActionCreator(actionTypes.SET_ENTITY);
 var setEntities = makeActionCreator(actionTypes.SET_ENTITIES);
 var setAuth = makeActionCreator(actionTypes.SET_AUTH);
 var resetAuth = makeActionCreator(actionTypes.RESET_AUTH);
-var setLoadingScreen = makeActionCreator(actionTypes.SET_LOADING_SCREEN);
-var setModal = makeActionCreator(actionTypes.SET_MODAL);
-var addNotification = makeActionCreator(actionTypes.ADD_NOTIFICATION);
-var removeNotification = makeActionCreator(actionTypes.REMOVE_NOTIFICATION);
-var setShownContextualActions = makeActionCreator(actionTypes.SET_SHOWN_CONTEXTUAL_ACTIONS);
-var setIsDrawerOpen = makeActionCreator(actionTypes.SET_IS_DRAWER_OPEN);
-var setIsViewerReady = makeActionCreator(actionTypes.SET_IS_VIEWER_READY);
-var setDrawerExpandedId = makeActionCreator(actionTypes.SET_DRAWER_EXPANDED_ID);
-var setIsOpenSaveModal = makeActionCreator(actionTypes.SET_IS_OPEN_SAVE_MODAL);
-var setCurrentTourId = makeActionCreator(actionTypes.SET_CURRENT_TOUR_ID);
-var setCurrentTourStep = makeActionCreator(actionTypes.SET_CURRENT_TOUR_STEP);
-var resetTour = makeActionCreator(actionTypes.RESET_TOUR);
-var setIsTourPanelOpen = makeActionCreator(actionTypes.SET_IS_TOUR_PANEL_OPEN);
-var setTourPanelMode = makeActionCreator(actionTypes.SET_TOUR_PANEL_MODE);
-var setScenarioId = makeActionCreator(actionTypes.SET_SCENARIO_ID);
-var setIsStudentViewActivated = makeActionCreator(actionTypes.SET_IS_STUDENT_VIEW_ACTIVATED);
-var setSsrFakePageId = makeActionCreator(actionTypes.SET_SSR_FAKE_PAGE_ID);
 
 // src/reducers/entities.ts
 var deleteEntityReducer = (state, payload) => {
   const { path } = payload;
-  return _2.omit(path, state);
+  return _5.omit(path, state);
 };
 var updateEntityReducer = (state, payload) => {
   const { path, entity } = payload;
-  const currentEntity = _2.get(path, state);
-  return _2.set(path, _2.merge(currentEntity, entity), state);
+  const currentEntity = _5.get(path, state);
+  return _5.set(path, _5.merge(currentEntity, entity), state);
 };
 var setEntityReducer = (state, payload) => {
   const { path, entity } = payload;
-  return _2.set(path, entity, state);
+  return _5.set(path, entity, state);
 };
 var shallowAssign = (old, next, transform) => {
   let updated = false;
-  const merged = _2.flow(
-    _2.toPairs,
-    _2.reduce((memo, [key, val]) => {
-      if (_2.isEmpty(val)) return memo;
+  const merged = _5.flow(
+    _5.toPairs,
+    _5.reduce((memo, [key, val]) => {
+      if (_5.isEmpty(val)) return memo;
       if (!old[key]) {
         updated = true;
         memo[key] = val;
@@ -103,7 +845,7 @@ var shallowAssign = (old, next, transform) => {
         return memo;
       }
       return memo;
-    }, _2.clone(old))
+    }, _5.clone(old))
   )(next);
   return updated ? merged : old;
 };
@@ -112,7 +854,7 @@ var setEntitiesReducer = (state, payload) => {
     return shallowAssign(
       entityKind,
       nextEntityKind,
-      (oldEntity, nextEntity) => _2.isEqual(oldEntity, nextEntity) ? oldEntity : _2.assign(oldEntity, nextEntity)
+      (oldEntity, nextEntity) => _5.isEqual(oldEntity, nextEntity) ? oldEntity : _5.assign(oldEntity, nextEntity)
     );
   });
 };
@@ -127,13 +869,229 @@ var entities = makeReducer(
 );
 var entities_default = entities;
 
+// src/reducers/auth.ts
+init_define_import_meta();
+import { makeReducer as makeReducer2 } from "@lls/utils";
+import _6 from "lodash/fp.js";
+var initialState = {
+  id: void 0,
+  role: null,
+  token: null,
+  isStudent: null,
+  isTeacher: null,
+  isPremium: null,
+  userPages: null,
+  username: null,
+  llsUserId: null
+};
+var auth = makeReducer2(initialState, {
+  [actionTypes.SET_AUTH]: _6.assign,
+  [actionTypes.RESET_AUTH]: _6.constant(initialState)
+});
+var auth_default = auth;
+
 // src/schema/index.ts
-var schema = "TODO";
-var schema_default = schema;
+init_define_import_meta();
+var import_normalizr = __toESM(require_normalizr(), 1);
+import _7 from "lodash/fp.js";
+var document = new import_normalizr.schema.Entity("documents", {}, { idAttribute: "resourceId" });
+var subject = new import_normalizr.schema.Entity("subjects");
+var level = new import_normalizr.schema.Entity("levels");
+var book = new import_normalizr.schema.Entity("books");
+var tool = new import_normalizr.schema.Entity("tools");
+var chapter = new import_normalizr.schema.Entity("chapters");
+var page = new import_normalizr.schema.Entity("pages");
+var resource = new import_normalizr.schema.Entity("resources");
+var user = new import_normalizr.schema.Entity("users");
+var school = new import_normalizr.schema.Entity("schools");
+var teacher = new import_normalizr.schema.Entity("teachers");
+var faq = new import_normalizr.schema.Entity("faq");
+var product = new import_normalizr.schema.Entity("products");
+var communityProjects = new import_normalizr.schema.Entity("communityProjects");
+var grammarRule = new import_normalizr.schema.Entity("grammarRules", {}, { idAttribute: "objectID" });
+var mainNotification = new import_normalizr.schema.Entity("mainNotifications");
+var explorerResult = new import_normalizr.schema.Entity("explorerResults", {}, { idAttribute: "resourceId" });
+var drawerNotification = new import_normalizr.schema.Entity("drawerNotifications");
+var copyNotification = new import_normalizr.schema.Entity("copyNotifications");
+var quote = new import_normalizr.schema.Entity("quotes");
+var group = new import_normalizr.schema.Entity("groups");
+var analytic = new import_normalizr.schema.Entity("analytics");
+var contact = new import_normalizr.schema.Entity("contact");
+var collection = new import_normalizr.schema.Entity("collections");
+var sharedPage = new import_normalizr.schema.Entity("sharedPages");
+var student = new import_normalizr.schema.Entity("students");
+var news = new import_normalizr.schema.Entity("news");
+var schoolType = new import_normalizr.schema.Entity("schoolTypes");
+var panorama = new import_normalizr.schema.Entity("panoramas");
+var premiumResource = new import_normalizr.schema.Entity("premiumResources");
+var garDivision = new import_normalizr.schema.Entity("garDivisions");
+var define = (el, scheme) => {
+  el.define(scheme);
+  return scheme;
+};
+var bookSchema = define(book, {
+  chapters: [chapter],
+  collection,
+  firstValidPage: page,
+  levels: [level],
+  news: [news],
+  oldBook: book,
+  premiumResources: [premiumResource],
+  revisionPages: [page],
+  subjects: [subject],
+  textbooks: [book],
+  tools: [tool],
+  workbooks: [book],
+  workplans: [book]
+});
+var garDivisionSchema = define(garDivision, {
+  students: [user],
+  school
+});
+var chapterSchema = define(chapter, {
+  book,
+  oldBook: book,
+  oldChapter: chapter,
+  pages: [page],
+  resources: [resource]
+});
+var pageSchema = define(page, {
+  book,
+  chapter,
+  oldBook: book,
+  oldChapter: chapter,
+  oldLesson: page,
+  originalPage: page,
+  parent: page,
+  sharedGroups: [group],
+  sharedTeacher: user,
+  sharedUsers: [user],
+  user
+});
+var userSchema = define(user, {
+  books: [book],
+  booksV2: [book],
+  contacts: [contact],
+  copies: [page],
+  copyNotifications: [copyNotification],
+  drawerNotifications: [drawerNotification],
+  garDivisions: [garDivision],
+  groups: [group],
+  lastBooksViewed: [book],
+  lastPagesViewed: [page],
+  levels: [level],
+  mainNotifications: [mainNotification],
+  pages: [page],
+  schools: [school],
+  sharedPages: [sharedPage],
+  students: [student],
+  subjects: [subject],
+  teachers: [teacher],
+  userPages: [page]
+});
+var notificationSchema = define(mainNotification, { page });
+drawerNotification.define({ page });
+copyNotification.define({ page });
+var resourceSchema = define(resource, {
+  chapter,
+  page
+});
+var toolSchema = define(tool, {
+  books: [book]
+});
+var sharedPageSchema = define(sharedPage, {
+  user,
+  chapter,
+  parent: page,
+  book,
+  originalPage: page
+});
+var studentSchema = define(student, {
+  levels: [level]
+});
+var teacherSchema = define(teacher, {
+  schools: [school],
+  subjects: [subject]
+});
+var productSchema = define(product, {
+  books: [book]
+});
+var groupSchema = define(group, {
+  owner: teacher,
+  students: [student]
+});
+var newsSchema = define(news, {
+  books: [book],
+  subjects: [subject],
+  levels: [level]
+});
+var premiumResourceSchema = define(premiumResource, {
+  book
+});
+var querySchema = {
+  viewer: {
+    addCorrectionsToGroup: group,
+    addCorrectionsToStudents: page,
+    addPageAppreciation: page,
+    addStudentToGroup: group,
+    books: { hits: [book] },
+    chapters: { hits: [chapter] },
+    createEstimate: quote,
+    createGroup: group,
+    createPage: page,
+    createUser: user,
+    documents: { hits: [document] },
+    explorerResults: [explorerResult],
+    levels: [level],
+    me: user,
+    // mutations
+    pages: { hits: [page] },
+    panoramas: [panorama],
+    parents: { hits: [page] },
+    //pages alias
+    product: { hits: [product] },
+    schoolTypes: { hits: [schoolType] },
+    sharePageToGroup: page,
+    sharePageToUsers: page,
+    subjects: { hits: [subject] },
+    updateCopyNotification: copyNotification,
+    updateDrawerNotification: drawerNotification,
+    updateGroup: group,
+    updateMainNotification: mainNotification,
+    updatePage: page,
+    updateTrialUser: user,
+    updateUserLastActivitySeenAt: user,
+    updateUser: user
+  },
+  auth: {
+    user
+  },
+  marketing: {
+    addLikeFaq: faq,
+    communityProjects: [communityProjects],
+    createAnalytics: analytic,
+    faq: [faq]
+  },
+  static: {
+    projetVoltaire: {
+      grammarRules: [grammarRule]
+    }
+  }
+};
+var normalizeData = _7.flow((data) => (0, import_normalizr.normalize)(data, querySchema));
 export {
+  auth_default as authReducer,
   entities_default as entitiesReducer,
+  getCurrentUser,
   getSchool,
   getSchools,
-  schema_default as schema,
-  searchSchools
+  getUser,
+  getUsers,
+  makeSearchSchools,
+  makeSearchUsers,
+  normalizeData,
+  querySchema,
+  searchSchools,
+  searchUsers,
+  setEntitiesReducer
 };

package/package.json

@@ -2,7 +2,7 @@
   "name": "@lls/store",
   "description": "model de donnée et selecteurs",
   "homepage": "https://github.com/lelivrescolaire/monorepo/tree/dev/libs/store",
-  "version": "24.1.57-3bf4faf5",
+  "version": "24.1.57-4e182f7c",
   "type": "module",
   "types": "./lib/builttypes/store/src/index.d.ts",
   "exports": {
@@ -37,14 +37,17 @@
     "lodash": "4.17.21",
     "react": "18.3.1",
     "reselect": "4.1.8",
-    "typescript": "5.5.3",
+    "typescript": "5.5.4",
     "vite": "5.3.3",
     "vite-tsconfig-paths": "4.3.2",
     "vitest": "2.0.0",
-    "@lls/utils": "24.1.57-3bf4faf5",
-    "@lls/vitescripts": "24.1.57-3bf4faf5"
+    "@lls/utils": "24.1.57-4e182f7c",
+    "@lls/vitescripts": "24.1.57-4e182f7c"
   },
   "license": "ISC",
+  "dependencies": {
+    "normalizr": "3.6.2"
+  },
   "scripts": {
     "build": "node build.mjs",
     "lint": "pnpm biome check --apply src __tests__",