@apia/util 0.3.6 → 1.0.1

package/dist/index.js

@@ -5,7 +5,7 @@ import customParseFormat from 'dayjs/plugin/customParseFormat';
 import axios from 'axios';
 import FileSaver from 'file-saver';
 import * as React from 'react';
-import React__default, { useRef, useMemo, useState, useEffect, useCallback, createContext, useContext } from 'react';
+import React__default, { useRef, useCallback, useEffect, useState, useMemo, createContext, useContext } from 'react';
 import { isFunction as isFunction$1, uniqueId } from 'lodash-es';
 import { jsx } from 'react/jsx-runtime';
 import xml2js from 'xml2js';
@@ -661,15 +661,15 @@ function isChild(element, checkParent) {
   return !!getSpecificParent(element, checkParent);
 }
 
-var __accessCheck$6 = (obj, member, msg) => {
+var __accessCheck$7 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$6 = (obj, member, getter) => {
-  __accessCheck$6(obj, member, "read from private field");
+var __privateGet$7 = (obj, member, getter) => {
+  __accessCheck$7(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$6 = (obj, member, value) => {
+var __privateAdd$7 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
@@ -678,7 +678,7 @@ var _parameters;
 class Url {
   constructor(baseUrl, defaultAllowMultiple = true) {
     this.defaultAllowMultiple = defaultAllowMultiple;
-    __privateAdd$6(this, _parameters, {});
+    __privateAdd$7(this, _parameters, {});
     const [base, query] = baseUrl.split("?");
     this.base = base;
     query == null ? void 0 : query.split("&").forEach((current) => {
@@ -688,9 +688,9 @@ class Url {
   }
   addParameter(name, value, allowMultiple) {
     if (allowMultiple === void 0 && !this.defaultAllowMultiple || allowMultiple === false)
-      __privateGet$6(this, _parameters)[name] = String(value);
+      __privateGet$7(this, _parameters)[name] = String(value);
     else
-      __privateGet$6(this, _parameters)[name] = __privateGet$6(this, _parameters)[name] ? [...arrayOrArray(__privateGet$6(this, _parameters)[name]), String(value)] : [String(value)];
+      __privateGet$7(this, _parameters)[name] = __privateGet$7(this, _parameters)[name] ? [...arrayOrArray(__privateGet$7(this, _parameters)[name]), String(value)] : [String(value)];
   }
   addParameters(parameters) {
     parameters.forEach(
@@ -698,10 +698,10 @@ class Url {
     );
   }
   getParameter(name) {
-    return __privateGet$6(this, _parameters)[name];
+    return __privateGet$7(this, _parameters)[name];
   }
   toString() {
-    const parametersArray = Object.entries(__privateGet$6(this, _parameters));
+    const parametersArray = Object.entries(__privateGet$7(this, _parameters));
     return `${this.base}${parametersArray.length > 0 ? `?${parametersArray.map(
       ([name, value]) => Array.isArray(value) ? value.map((current) => `${name}=${current}`).join("&") : `${name}=${String(value)}`
     ).join("&")}` : ""}`;
@@ -733,15 +733,15 @@ function enableChildrenFocus(parent) {
   });
 }
 
-var __accessCheck$5 = (obj, member, msg) => {
+var __accessCheck$6 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$5 = (obj, member, getter) => {
-  __accessCheck$5(obj, member, "read from private field");
+var __privateGet$6 = (obj, member, getter) => {
+  __accessCheck$6(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$5 = (obj, member, value) => {
+var __privateAdd$6 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
@@ -775,38 +775,38 @@ function eventEmitterBaseFunction() {
 }
 class EventEmitter {
   constructor() {
-    __privateAdd$5(this, _emitter$1, eventEmitterBaseFunction());
+    __privateAdd$6(this, _emitter$1, eventEmitterBaseFunction());
   }
   on(eventName, fn) {
-    __privateGet$5(this, _emitter$1).on(eventName, fn);
+    __privateGet$6(this, _emitter$1).on(eventName, fn);
     return () => {
-      __privateGet$5(this, _emitter$1).off(eventName, fn);
+      __privateGet$6(this, _emitter$1).off(eventName, fn);
     };
   }
   off(eventName, fn) {
-    __privateGet$5(this, _emitter$1).off(eventName, fn);
+    __privateGet$6(this, _emitter$1).off(eventName, fn);
   }
   emit(eventName, params) {
-    __privateGet$5(this, _emitter$1).emit(eventName, params);
+    __privateGet$6(this, _emitter$1).emit(eventName, params);
   }
 }
 _emitter$1 = new WeakMap();
 
-var __accessCheck$4 = (obj, member, msg) => {
+var __accessCheck$5 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$4 = (obj, member, getter) => {
-  __accessCheck$4(obj, member, "read from private field");
+var __privateGet$5 = (obj, member, getter) => {
+  __accessCheck$5(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$4 = (obj, member, value) => {
+var __privateAdd$5 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
 var __privateMethod$2 = (obj, member, method) => {
-  __accessCheck$4(obj, member, "access private method");
+  __accessCheck$5(obj, member, "access private method");
   return method;
 };
 var _emitter, _getEventName, getEventName_fn;
@@ -839,46 +839,47 @@ function eventEmitter() {
 class HashedEventEmitter {
   constructor(hashMethod) {
     this.hashMethod = hashMethod;
-    __privateAdd$4(this, _getEventName);
-    __privateAdd$4(this, _emitter, eventEmitter());
+    __privateAdd$5(this, _getEventName);
+    __privateAdd$5(this, _emitter, eventEmitter());
   }
   on(hash, eventName, fn) {
     const actualEventName = __privateMethod$2(this, _getEventName, getEventName_fn).call(this, hash, eventName);
-    __privateGet$4(this, _emitter).on(actualEventName, fn);
+    __privateGet$5(this, _emitter).on(actualEventName, fn);
     return () => {
-      __privateGet$4(this, _emitter).off(actualEventName, fn);
+      __privateGet$5(this, _emitter).off(actualEventName, fn);
     };
   }
   off(hash, eventName, fn) {
     const actualEventName = __privateMethod$2(this, _getEventName, getEventName_fn).call(this, hash, eventName);
-    __privateGet$4(this, _emitter).off(actualEventName, fn);
+    __privateGet$5(this, _emitter).off(actualEventName, fn);
   }
   emit(hash, eventName, params) {
     const actualEventName = __privateMethod$2(this, _getEventName, getEventName_fn).call(this, hash, eventName);
-    __privateGet$4(this, _emitter).emit(actualEventName, params);
+    __privateGet$5(this, _emitter).emit(actualEventName, params);
+    __privateGet$5(this, _emitter).emit(eventName, params);
   }
 }
 _emitter = new WeakMap();
 _getEventName = new WeakSet();
 getEventName_fn = function(hash, eventName) {
-  return `${this.hashMethod(hash)}_${eventName}`;
+  return hash === "*" ? eventName : `${this.hashMethod(hash)}_${eventName}`;
 };
 
-var __accessCheck$3 = (obj, member, msg) => {
+var __accessCheck$4 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$3 = (obj, member, getter) => {
-  __accessCheck$3(obj, member, "read from private field");
+var __privateGet$4 = (obj, member, getter) => {
+  __accessCheck$4(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$3 = (obj, member, value) => {
+var __privateAdd$4 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$3 = (obj, member, value, setter) => {
-  __accessCheck$3(obj, member, "write to private field");
+var __privateSet$4 = (obj, member, value, setter) => {
+  __accessCheck$4(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
@@ -886,34 +887,34 @@ var _value;
 class WithEventsValue extends EventEmitter {
   constructor(value) {
     super();
-    __privateAdd$3(this, _value, void 0);
-    __privateSet$3(this, _value, value);
+    __privateAdd$4(this, _value, void 0);
+    __privateSet$4(this, _value, value);
   }
   get value() {
-    return __privateGet$3(this, _value);
+    return __privateGet$4(this, _value);
   }
   set value(value) {
-    __privateSet$3(this, _value, value);
+    __privateSet$4(this, _value, value);
     this.emit("update", value);
   }
 }
 _value = new WeakMap();
 
-var __accessCheck$2 = (obj, member, msg) => {
+var __accessCheck$3 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$2 = (obj, member, getter) => {
-  __accessCheck$2(obj, member, "read from private field");
+var __privateGet$3 = (obj, member, getter) => {
+  __accessCheck$3(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$2 = (obj, member, value) => {
+var __privateAdd$3 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$2 = (obj, member, value, setter) => {
-  __accessCheck$2(obj, member, "write to private field");
+var __privateSet$3 = (obj, member, value, setter) => {
+  __accessCheck$3(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
@@ -922,7 +923,7 @@ const historySize = 50;
 const globalFocus = new (_a$2 = class {
   constructor() {
     this.focused = [];
-    __privateAdd$2(this, _onFocusCallbacks, []);
+    __privateAdd$3(this, _onFocusCallbacks, []);
     debugDispatcher.on(
       "focusHistory",
       () => {
@@ -932,12 +933,12 @@ const globalFocus = new (_a$2 = class {
     );
   }
   offFocus(cb) {
-    __privateSet$2(this, _onFocusCallbacks, __privateGet$2(this, _onFocusCallbacks).filter(
+    __privateSet$3(this, _onFocusCallbacks, __privateGet$3(this, _onFocusCallbacks).filter(
       (current) => current !== cb
     ));
   }
   onFocus(cb) {
-    __privateGet$2(this, _onFocusCallbacks).push(cb);
+    __privateGet$3(this, _onFocusCallbacks).push(cb);
     return () => {
       this.offFocus(cb);
     };
@@ -954,7 +955,7 @@ const globalFocus = new (_a$2 = class {
     if (this.focused.length > historySize) {
       this.focused = this.focused.splice(0, historySize);
     }
-    __privateGet$2(this, _onFocusCallbacks).forEach((cb) => cb());
+    __privateGet$3(this, _onFocusCallbacks).forEach((cb) => cb());
   }
   get list() {
     return [...this.focused];
@@ -981,90 +982,526 @@ const globalFocus = new (_a$2 = class {
   }
 }, _onFocusCallbacks = new WeakMap(), _a$2)();
 
-var __accessCheck$1 = (obj, member, msg) => {
+var __accessCheck$2 = (obj, member, msg) => {
   if (!member.has(obj))
     throw TypeError("Cannot " + msg);
 };
-var __privateGet$1 = (obj, member, getter) => {
-  __accessCheck$1(obj, member, "read from private field");
+var __privateGet$2 = (obj, member, getter) => {
+  __accessCheck$2(obj, member, "read from private field");
   return getter ? getter.call(obj) : member.get(obj);
 };
-var __privateAdd$1 = (obj, member, value) => {
+var __privateAdd$2 = (obj, member, value) => {
   if (member.has(obj))
     throw TypeError("Cannot add the same private member more than once");
   member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 };
-var __privateSet$1 = (obj, member, value, setter) => {
-  __accessCheck$1(obj, member, "write to private field");
+var __privateSet$2 = (obj, member, value, setter) => {
+  __accessCheck$2(obj, member, "write to private field");
   setter ? setter.call(obj, value) : member.set(obj, value);
   return value;
 };
 var __privateMethod$1 = (obj, member, method) => {
-  __accessCheck$1(obj, member, "access private method");
+  __accessCheck$2(obj, member, "access private method");
   return method;
 };
 var _hasReleasedFirstTime, _wasReleasedFirstTime, _isForced, _locks, _shoutLockState, shoutLockState_fn, _a$1;
 const screenLocker = new (_a$1 = class extends EventEmitter {
   constructor() {
     super();
-    __privateAdd$1(this, _shoutLockState);
-    __privateAdd$1(this, _hasReleasedFirstTime, false);
-    __privateAdd$1(this, _wasReleasedFirstTime, false);
-    __privateAdd$1(this, _isForced, false);
-    __privateAdd$1(this, _locks, {
+    __privateAdd$2(this, _shoutLockState);
+    __privateAdd$2(this, _hasReleasedFirstTime, false);
+    __privateAdd$2(this, _wasReleasedFirstTime, false);
+    __privateAdd$2(this, _isForced, false);
+    __privateAdd$2(this, _locks, {
       common: false
     });
     this.emit("ready");
   }
   get hasReleasedFirstTime() {
-    return __privateGet$1(this, _hasReleasedFirstTime);
+    return __privateGet$2(this, _hasReleasedFirstTime);
   }
   get isForced() {
-    return __privateGet$1(this, _isForced);
+    return __privateGet$2(this, _isForced);
   }
   /**
    * Permite saber si un bloqueo determinado está activo o si la clase tiene
    * forceLock activo.
    */
   isLocked(lockName = "common") {
-    return __privateGet$1(this, _locks)[lockName] || __privateGet$1(this, _isForced);
+    return __privateGet$2(this, _locks)[lockName] || __privateGet$2(this, _isForced);
   }
   lock(lockName = "common") {
-    __privateGet$1(this, _locks)[lockName] = true;
+    __privateGet$2(this, _locks)[lockName] = true;
     __privateMethod$1(this, _shoutLockState, shoutLockState_fn).call(this, lockName);
   }
   unlock(lockName = "common") {
     if (lockName === "common")
-      __privateSet$1(this, _hasReleasedFirstTime, true);
-    __privateGet$1(this, _locks)[lockName] = false;
+      __privateSet$2(this, _hasReleasedFirstTime, true);
+    __privateGet$2(this, _locks)[lockName] = false;
     __privateMethod$1(this, _shoutLockState, shoutLockState_fn).call(this, lockName);
   }
   force() {
-    __privateSet$1(this, _isForced, true);
+    __privateSet$2(this, _isForced, true);
     __privateMethod$1(this, _shoutLockState, shoutLockState_fn).call(this);
   }
   releaseForced() {
-    __privateSet$1(this, _isForced, false);
+    __privateSet$2(this, _isForced, false);
     __privateMethod$1(this, _shoutLockState, shoutLockState_fn).call(this);
   }
 }, _hasReleasedFirstTime = new WeakMap(), _wasReleasedFirstTime = new WeakMap(), _isForced = new WeakMap(), _locks = new WeakMap(), _shoutLockState = new WeakSet(), shoutLockState_fn = function(lockName) {
-  if (__privateGet$1(this, _isForced) || lockName === void 0) {
+  if (__privateGet$2(this, _isForced) || lockName === void 0) {
     this.emit("forcedStateChange", {
-      isForced: __privateGet$1(this, _isForced),
-      hasReleasedFirstTime: __privateGet$1(this, _hasReleasedFirstTime)
+      isForced: __privateGet$2(this, _isForced),
+      hasReleasedFirstTime: __privateGet$2(this, _hasReleasedFirstTime)
     });
   } else {
-    if (lockName === "common" && !__privateGet$1(this, _wasReleasedFirstTime) && __privateGet$1(this, _hasReleasedFirstTime)) {
+    if (lockName === "common" && !__privateGet$2(this, _wasReleasedFirstTime) && __privateGet$2(this, _hasReleasedFirstTime)) {
       this.emit("releaseForFirstTime");
     }
     this.emit("lockStateChange", {
       lockName,
-      hasReleasedFirstTime: __privateGet$1(this, _hasReleasedFirstTime),
-      isLocked: __privateGet$1(this, _locks)[lockName]
+      hasReleasedFirstTime: __privateGet$2(this, _hasReleasedFirstTime),
+      isLocked: __privateGet$2(this, _locks)[lockName]
     });
   }
 }, _a$1)();
 
+function useCombinedRefs(...refs) {
+  const [targetRef, setTargetRef] = React.useState();
+  React.useEffect(() => {
+    refs.forEach((ref) => {
+      if (!ref)
+        return;
+      if (typeof ref === "function") {
+        ref(targetRef);
+      } else {
+        ref.current = targetRef;
+      }
+    });
+  }, [refs, targetRef]);
+  return setTargetRef;
+}
+
+const useDebouncedCallback = (callback, { runWhenTriggered, timeout } = { runWhenTriggered: false, timeout: 200 }) => {
+  const timeoutRef = useRef(-1);
+  return useCallback(
+    (...params) => {
+      if (runWhenTriggered)
+        callback(...params);
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = setTimeout(
+        () => callback(...params),
+        timeout
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      );
+    },
+    [callback, runWhenTriggered, timeout]
+  );
+};
+
+function useLatest(value) {
+  const ref = useRef(value);
+  ref.current = value;
+  return ref;
+}
+
+function useMount(effect) {
+  const hasRun = useRef(false);
+  useEffect(() => {
+    if (!hasRun.current) {
+      hasRun.current = true;
+      return effect();
+    }
+  }, []);
+}
+
+function useUnmount(unmountCallback) {
+  useEffect(() => {
+    return unmountCallback;
+  }, []);
+}
+
+function usePrevious(value) {
+  const previousValue = useRef(void 0);
+  const currentValue = useRef(void 0);
+  previousValue.current = currentValue.current;
+  currentValue.current = value;
+  return previousValue;
+}
+
+function useStateRef(initialState) {
+  const [state, setState] = useState(initialState);
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  return [state, setState, stateRef];
+}
+
+function useUpdateEffect(effect, deps) {
+  const hasRunnedForFirstTime = useRef(false);
+  useEffect(() => {
+    if (hasRunnedForFirstTime.current) {
+      return effect();
+    }
+    hasRunnedForFirstTime.current = true;
+    return () => {
+    };
+  }, deps);
+}
+
+function shallowEqual(a, b) {
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a === "object" && a && typeof b === "object" && b) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+      return false;
+    for (let i = 0; i < aKeys.length; i++) {
+      if (a[aKeys[i]] !== b[bKeys[i]])
+        return false;
+    }
+  } else {
+    if (a !== b)
+      return false;
+  }
+  return true;
+}
+function shallowCompareArrays(a, b) {
+  if (a.length !== b.length)
+    return false;
+  for (let i = 0; i < a.length; i++) {
+    const differ = shallowEqual(a, b);
+    if (!differ)
+      return false;
+  }
+  return true;
+}
+function useShallowMemo(creator, deps) {
+  var _a;
+  const value = useRef(creator());
+  const previousDeps = usePrevious(deps);
+  if (!shallowEqual((_a = previousDeps.current) != null ? _a : [], deps)) {
+    value.current = creator();
+  }
+  return value.current;
+}
+
+var __defProp$6 = Object.defineProperty;
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$6.call(b, prop))
+      __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(b)) {
+      if (__propIsEnum$6.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
+    }
+  return a;
+};
+var __accessCheck$1 = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet$1 = (obj, member, getter) => {
+  __accessCheck$1(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd$1 = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet$1 = (obj, member, value, setter) => {
+  __accessCheck$1(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+var _onUpdateCbs;
+function upper(s) {
+  return `${s.charAt(0).toUpperCase()}${s.slice(1)}`;
+}
+function isUpdater(props) {
+  return typeof props === "function";
+}
+class BasicStoredElement {
+  constructor(props) {
+    __privateAdd$1(this, _onUpdateCbs, []);
+    this.props = {};
+    this.shoutUpdates = () => {
+      __privateGet$1(this, _onUpdateCbs).forEach((current) => current());
+    };
+    this.useProps = () => {
+      const [props, setState] = useState(this.props);
+      useMount(() => {
+        setState(__spreadValues$6({}, this.props));
+        return this.onUpdate(() => {
+          setState(__spreadValues$6({}, this.props));
+        });
+      });
+      return props;
+    };
+    this.props = props;
+  }
+  onUpdate(cb) {
+    __privateGet$1(this, _onUpdateCbs).push(cb);
+    return () => {
+      __privateSet$1(this, _onUpdateCbs, __privateGet$1(this, _onUpdateCbs).filter((current) => current !== cb));
+    };
+  }
+  update(newProps) {
+    const actualNewProps = isUpdater(newProps) ? newProps(this.props) : newProps;
+    this.props = __spreadValues$6(__spreadValues$6({}, this.props), actualNewProps);
+    this.shoutUpdates();
+  }
+}
+_onUpdateCbs = new WeakMap();
+class People extends BasicStoredElement {
+  getId() {
+    return this.props.name;
+  }
+}
+const r = makeStatefulStore({
+  people: People.prototype
+});
+r.actions.addPeople;
+r.actions.emptyPeople;
+r.actions.removePeople;
+r.hooks.usePeople;
+r.hooks.usePeopleById;
+r.hooks.usePeopleList;
+r.on.changePeople;
+r.on.changePeopleAmmount;
+r.on.changePeopleElement;
+r.state.getPeople;
+r.state.getPeopleState;
+r.state.updatePeople;
+function makeStatefulStore(entries, initialStates) {
+  const hookUseState = {};
+  const hookUseList = {};
+  const hookUseStateById = {};
+  const suscribeById = {};
+  const suscribeToList = {};
+  const suscribeToListCount = {};
+  const addActions = {};
+  const emptyActions = {};
+  const removeActions = {};
+  const getItemActions = {};
+  const getStateActions = {};
+  const updateItemActions = {};
+  Object.keys(entries).forEach((name) => {
+    const initialStateKey = `${upper(name)}State`;
+    let store = {};
+    const initialState = initialStates == null ? void 0 : initialStates[initialStateKey];
+    initialState == null ? void 0 : initialState.forEach((current) => {
+      store[current.getId()] = current;
+    });
+    let listStateChangeHandlers = [];
+    function shoutListStateChange() {
+      listStateChangeHandlers.forEach((current) => current());
+    }
+    const elementChangeHandlers = {};
+    function shoutListElementChange(id) {
+      var _a;
+      (_a = elementChangeHandlers[id]) == null ? void 0 : _a.forEach((current) => current());
+    }
+    let listCountChangeHandlers = [];
+    function shoutListCountChange() {
+      listCountChangeHandlers.forEach((current) => current());
+    }
+    const onUpdateElementSuscriptions = {};
+    const addKey = `add${upper(name)}`;
+    addActions[addKey] = (newElement) => {
+      let elId = newElement.getId();
+      let lastProps = __spreadValues$6({}, newElement.props);
+      store[elId] = newElement;
+      const suscription = newElement.onUpdate(() => {
+        const id = newElement.getId();
+        if (id !== elId) {
+          if (store[id]) {
+            newElement.update(lastProps);
+            throw new Error(
+              `Cannot set new id ${id} because it already exists`
+            );
+          }
+          delete store[elId];
+          store[id] = newElement;
+          elId = id;
+          lastProps = newElement.props;
+        }
+        shoutListElementChange(id);
+        shoutListStateChange();
+      });
+      onUpdateElementSuscriptions[newElement.getId()] = suscription;
+      shoutListStateChange();
+      shoutListCountChange();
+      shoutListElementChange(elId);
+    };
+    const emptyKey = `empty${upper(name)}`;
+    emptyActions[emptyKey] = () => {
+      Object.values(onUpdateElementSuscriptions).forEach(
+        (current) => current()
+      );
+      store = {};
+      shoutListCountChange();
+      shoutListStateChange();
+      Object.keys(elementChangeHandlers).forEach(
+        (current) => shoutListElementChange(current)
+      );
+    };
+    const removeKey = `remove${upper(name)}`;
+    removeActions[removeKey] = (id) => {
+      var _a;
+      (_a = onUpdateElementSuscriptions[id]) == null ? void 0 : _a.call(onUpdateElementSuscriptions);
+      delete store[id];
+      shoutListCountChange();
+      shoutListStateChange();
+      shoutListElementChange(id);
+    };
+    const getStateKey = `get${upper(name)}State`;
+    getStateActions[getStateKey] = () => {
+      return Object.values(store);
+    };
+    const getState = getStateActions[getStateKey];
+    const getItemKey = `get${upper(name)}`;
+    getItemActions[getItemKey] = (id) => {
+      return store[id];
+    };
+    const updateItemKey = `update${upper(name)}`;
+    updateItemActions[updateItemKey] = (id, newProps) => {
+      store[id].update(newProps);
+    };
+    const hookUseStateKey = `use${upper(name)}`;
+    hookUseState[hookUseStateKey] = () => {
+      const [state2, setState] = useState(getState());
+      useMount(() => {
+        setState(getState());
+        const eventHandler = () => {
+          setState(getState());
+        };
+        listStateChangeHandlers.push(eventHandler);
+        return () => {
+          listStateChangeHandlers = listStateChangeHandlers.filter(
+            (current) => current !== eventHandler
+          );
+        };
+      });
+      return state2;
+    };
+    const hookUseListKey = `use${upper(name)}List`;
+    hookUseList[hookUseListKey] = () => {
+      const [state2, setState] = useState(getState());
+      useMount(() => {
+        setState(getState());
+        const eventHandler = () => {
+          setState(getState());
+        };
+        listCountChangeHandlers.push(eventHandler);
+        return () => {
+          listCountChangeHandlers = listCountChangeHandlers.filter(
+            (current) => current !== eventHandler
+          );
+        };
+      });
+      return state2;
+    };
+    const hookUseStateByIdKey = `use${upper(
+      name
+    )}ById`;
+    hookUseStateById[hookUseStateByIdKey] = (id) => {
+      const [state2, setState] = useState({ obj: store[id] });
+      useMount(() => {
+        setState({ obj: store[id] });
+        const eventHandler = () => {
+          setState({ obj: store[id] });
+        };
+        if (!elementChangeHandlers[id])
+          elementChangeHandlers[id] = [];
+        elementChangeHandlers[id].push(eventHandler);
+        return () => {
+          elementChangeHandlers[id] = elementChangeHandlers[id].filter(
+            (current) => current !== eventHandler
+          );
+        };
+      });
+      return state2.obj;
+    };
+    const onChangeElementKey = `change${upper(
+      name
+    )}Element`;
+    suscribeById[onChangeElementKey] = (id, cb) => {
+      if (!elementChangeHandlers[id])
+        elementChangeHandlers[id] = [];
+      const innerCb = () => {
+        cb(store[id]);
+      };
+      elementChangeHandlers[id].push(innerCb);
+      return () => {
+        elementChangeHandlers[id] = elementChangeHandlers[id].filter(
+          (current) => current !== innerCb
+        );
+      };
+    };
+    const onChangeListKey = `change${upper(
+      name
+    )}`;
+    suscribeToList[onChangeListKey] = (cb) => {
+      const innerCb = () => {
+        cb(getState());
+      };
+      listStateChangeHandlers.push(innerCb);
+      return () => {
+        listStateChangeHandlers = listStateChangeHandlers.filter(
+          (current) => current !== innerCb
+        );
+      };
+    };
+    const onChangeListCountKey = `change${upper(
+      name
+    )}Ammount`;
+    suscribeToListCount[onChangeListCountKey] = (cb) => {
+      const innerCb = () => {
+        cb(getState());
+      };
+      listCountChangeHandlers.push(innerCb);
+      return () => {
+        listCountChangeHandlers = listCountChangeHandlers.filter(
+          (current) => current !== innerCb
+        );
+      };
+    };
+  });
+  const actions = Object.assign(
+    {},
+    addActions,
+    removeActions,
+    emptyActions
+  );
+  const hooks = Object.assign({}, hookUseState, hookUseStateById, hookUseList);
+  const on = Object.assign(
+    {},
+    suscribeById,
+    suscribeToList,
+    suscribeToListCount
+  );
+  const state = Object.assign(
+    {},
+    getStateActions,
+    getItemActions,
+    updateItemActions
+  );
+  return Object.assign(
+    {},
+    { hooks },
+    { actions },
+    { state },
+    { on }
+  );
+}
+
 const persistentStorage = new Proxy(
   {
     remove(prop) {
@@ -1439,86 +1876,112 @@ const focus = new (_a = class {
   });
 }, _a)(document.getElementById("root"));
 
-function useCombinedRefs(...refs) {
-  const [targetRef, setTargetRef] = React.useState();
-  React.useEffect(() => {
-    refs.forEach((ref) => {
-      if (!ref)
-        return;
-      if (typeof ref === "function") {
-        ref(targetRef);
-      } else {
-        ref.current = targetRef;
+var __defProp$5 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b)) {
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+class History extends EventEmitter {
+  constructor(onCloseWindow, configuration = { maxLength: 100 }) {
+    super();
+    this.configuration = configuration;
+    this.autocloseTimeout = -1;
+    this.currentStep = 0;
+    this.content = [];
+    this.enabled = true;
+    this._isOpen = false;
+    this.timeoutMs = 350;
+    this.closeWindow = () => {
+      if (this._isOpen) {
+        this.onCloseWindow(this.push.bind(this));
+        this._isOpen = false;
       }
-    });
-  }, [refs, targetRef]);
-  return setTargetRef;
-}
-
-const useDebouncedCallback = (callback, { runWhenTriggered, timeout } = { runWhenTriggered: false, timeout: 200 }) => {
-  const timeoutRef = useRef(-1);
-  return useCallback(
-    (...params) => {
-      if (runWhenTriggered)
-        callback(...params);
-      clearTimeout(timeoutRef.current);
-      timeoutRef.current = setTimeout(
-        () => callback(...params),
-        timeout
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    };
+    this.getEvent = () => {
+      const stepCount = this.content.length - 1;
+      const event = {
+        content: this.content[this.currentStep],
+        currentStep: this.currentStep,
+        stepCount,
+        hasNext: this.currentStep < stepCount,
+        hasPrevious: this.currentStep >= 0
+      };
+      return event;
+    };
+    this.push = (el) => {
+      this.content = [...this.content.slice(0, this.currentStep + 1), el];
+      this.content = this.content.slice(
+        Math.max(0, this.content.length - this.configuration.maxLength)
       );
-    },
-    [callback, runWhenTriggered, timeout]
-  );
-};
-
-function useLatest(value) {
-  const ref = useRef(value);
-  ref.current = value;
-  return ref;
-}
-
-function useMount(effect) {
-  const hasRun = useRef(false);
-  useEffect(() => {
-    if (!hasRun.current) {
-      hasRun.current = true;
-      return effect();
-    }
-  }, []);
-}
-
-function useUnmount(unmountCallback) {
-  useEffect(() => {
-    return unmountCallback;
-  }, []);
-}
-
-function usePrevious(value) {
-  const previousValue = useRef(void 0);
-  const currentValue = useRef(void 0);
-  previousValue.current = currentValue.current;
-  currentValue.current = value;
-  return previousValue;
-}
-
-function useStateRef(initialState) {
-  const [state, setState] = useState(initialState);
-  const stateRef = useRef(state);
-  stateRef.current = state;
-  return [state, setState, stateRef];
-}
-
-function useUpdateEffect(effect, deps) {
-  const hasRunnedForFirstTime = useRef(false);
-  useEffect(() => {
-    if (hasRunnedForFirstTime.current) {
-      return effect();
-    }
-    hasRunnedForFirstTime.current = true;
-    return () => {
+      this.currentStep = this.content.length - 1;
+      this.shoutStepChange(true);
     };
-  }, deps);
+    this.shoutStepChange = (fromPush) => {
+      try {
+        this.emit("stepChange", __spreadProps$3(__spreadValues$5({}, this.getEvent()), { fromPush }));
+      } catch (e) {
+        console.error(e);
+      }
+    };
+    this.hooks = {
+      useCountChange: (onChange) => {
+        useMount(() => {
+          onChange(this.getEvent());
+          this.on("stepChange", () => {
+            onChange(this.getEvent());
+          });
+        });
+      }
+    };
+    this.back = () => {
+      if (this.currentStep >= 0) {
+        this.currentStep -= 1;
+        this.shoutStepChange();
+      }
+    };
+    this.disable = () => {
+      this.enabled = false;
+    };
+    this.enable = () => {
+      this.enabled = true;
+    };
+    this.forward = () => {
+      if (this.currentStep < this.content.length - 1) {
+        this.currentStep += 1;
+        this.shoutStepChange();
+      }
+    };
+    this.openWindow = () => {
+      if (!this.enabled)
+        return;
+      this._isOpen = true;
+      clearTimeout(this.autocloseTimeout);
+      this.autocloseTimeout = setTimeout(() => {
+        this.closeWindow();
+      }, this.timeoutMs);
+    };
+    this.updateConfig = (newConfiguration) => {
+      this.configuration = __spreadValues$5(__spreadValues$5({}, this.configuration), newConfiguration);
+    };
+    this.onCloseWindow = onCloseWindow;
+  }
+  get isOpen() {
+    return this._isOpen;
+  }
 }
 
 const ImperativeComponentContext = createContext(
@@ -2193,4 +2656,4 @@ const parseXmlAsync = (xml) => __async(void 0, null, function* () {
   return result;
 });
 
-export { EventEmitter, HashedEventEmitter, PropsSelectorUndefinedObject, PropsStore, Url, WithEventsValue, addBoundary, animate, apiaDateToStandarFormat, arrayOrArray, autoDisconnectMutationObserver, cantFocusSelector, customEvents, dateToApiaFormat, debugDispatcher, decrypt, disableChildrenFocus, downloadUrl, enableChildrenFocus, enableDebugDispatcher, encrypt, eventEmitterBaseFunction, findOffsetRelativeToScrollParent, findScrollContainer, focus, focusSelector, formatMessage, getDateFormat, getFocusSelector, getIndex, getLabel, getSpecificParent, getValueByPath, globalFocus, isChild, isDebugDispatcherEnabled, isPropsConfigurationObject, makeImperativeComponent, makeSingleImperativeComponent, noNaN, notificationsSelector, parseAsSize, parseXmlAsync, persistentStorage, propsStore, screenLocker, scrollParentIntoElement, setValueByPath, shortcutController, toBoolean, ucfirst, useCombinedRefs, useDebouncedCallback, useDebouncedState, useDomState, useImperativeComponentContext, useImperativeComponentEvents, useLatest, useLocalStorage, useMount, usePanAndZoom, usePrevious, usePropsSelector, useStateRef, useUnmount, useUpdateEffect };
+export { BasicStoredElement, EventEmitter, HashedEventEmitter, History, PropsSelectorUndefinedObject, PropsStore, Url, WithEventsValue, addBoundary, animate, apiaDateToStandarFormat, arrayOrArray, autoDisconnectMutationObserver, cantFocusSelector, customEvents, dateToApiaFormat, debugDispatcher, decrypt, disableChildrenFocus, downloadUrl, enableChildrenFocus, enableDebugDispatcher, encrypt, eventEmitterBaseFunction, findOffsetRelativeToScrollParent, findScrollContainer, focus, focusSelector, formatMessage, getDateFormat, getFocusSelector, getIndex, getLabel, getSpecificParent, getValueByPath, globalFocus, isChild, isDebugDispatcherEnabled, isPropsConfigurationObject, makeImperativeComponent, makeSingleImperativeComponent, makeStatefulStore, noNaN, notificationsSelector, parseAsSize, parseXmlAsync, persistentStorage, propsStore, screenLocker, scrollParentIntoElement, setValueByPath, shallowCompareArrays, shallowEqual, shortcutController, toBoolean, ucfirst, useCombinedRefs, useDebouncedCallback, useDebouncedState, useDomState, useImperativeComponentContext, useImperativeComponentEvents, useLatest, useLocalStorage, useMount, usePanAndZoom, usePrevious, usePropsSelector, useShallowMemo, useStateRef, useUnmount, useUpdateEffect };