@lls/store 24.1.57-9de21c94 → 24.1.57-db9af210

package/README.md

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

package/lib/index.js

@@ -33,6 +33,253 @@ var init_define_import_meta = __esm({
   }
 });
 
+// ../../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) {
@@ -488,27 +735,65 @@ init_define_import_meta();
 
 // src/selectors/school.ts
 init_define_import_meta();
-import {
-  createSearchSelector,
-  filterEntitiesSimpleFieldByValues,
-  makeGetAllEntities,
-  makeGetEntityById
-} from "@lls/utils";
+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";
 
 // src/actions/index.ts
 init_define_import_meta();
@@ -517,33 +802,37 @@ var actionTypes = {
   DELETE_ENTITY: "DELETE_ENTITY",
   UPDATE_ENTITY: "UPDATE_ENTITY",
   SET_ENTITY: "SET_ENTITY",
-  SET_ENTITIES: "SET_ENTITIES"
+  SET_ENTITIES: "SET_ENTITIES",
+  RESET_AUTH: "RESET_AUTH",
+  SET_AUTH: "SET_AUTH"
 };
 var deleteEntity = makeActionCreator(actionTypes.DELETE_ENTITY);
 var updateEntity = makeActionCreator(actionTypes.UPDATE_ENTITY);
 var setEntity = makeActionCreator(actionTypes.SET_ENTITY);
 var setEntities = makeActionCreator(actionTypes.SET_ENTITIES);
+var setAuth = makeActionCreator(actionTypes.SET_AUTH);
+var resetAuth = makeActionCreator(actionTypes.RESET_AUTH);
 
 // 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;
@@ -556,7 +845,7 @@ var shallowAssign = (old, next, transform) => {
         return memo;
       }
       return memo;
-    }, _2.clone(old))
+    }, _5.clone(old))
   )(next);
   return updated ? merged : old;
 };
@@ -565,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)
     );
   });
 };
@@ -580,10 +869,31 @@ 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
 init_define_import_meta();
 var import_normalizr = __toESM(require_normalizr(), 1);
-import _3 from "lodash/fp.js";
+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");
@@ -768,12 +1078,20 @@ var querySchema = {
     }
   }
 };
-var normalizeData = _3.flow((data) => (0, import_normalizr.normalize)(data, querySchema));
+var normalizeData = _7.flow((data) => (0, import_normalizr.normalize)(data, querySchema));
 export {
+  auth_default as authReducer,
   entities_default as entitiesReducer,
+  getCurrentUser,
   getSchool,
   getSchools,
+  getUser,
+  getUsers,
+  makeSearchSchools,
+  makeSearchUsers,
   normalizeData,
   querySchema,
-  searchSchools
+  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-9de21c94",
+  "version": "24.1.57-db9af210",
   "type": "module",
   "types": "./lib/builttypes/store/src/index.d.ts",
   "exports": {
@@ -41,8 +41,8 @@
     "vite": "5.3.3",
     "vite-tsconfig-paths": "4.3.2",
     "vitest": "2.0.0",
-    "@lls/utils": "24.1.57-9de21c94",
-    "@lls/vitescripts": "24.1.57-9de21c94"
+    "@lls/utils": "24.1.57-db9af210",
+    "@lls/vitescripts": "24.1.57-db9af210"
   },
   "license": "ISC",
   "dependencies": {