@apia/util 0.3.6 → 1.0.1

package/cleanDist.json

@@ -1,3 +1,3 @@
 {
-  "cleanDist": 0.7197744380857216
+  "cleanDist": 0.4517589736941394
 }

package/dist/index.d.ts

@@ -380,9 +380,9 @@ declare class HashedEventEmitter<T extends TEventMap, HashData extends TEventMap
     #private;
     private hashMethod;
     constructor(hashMethod: (hash: HashData) => string);
-    on<K extends TEventKey<T>>(hash: HashData, eventName: K, fn: TEventReceiver<T[K]>): () => void;
-    off<K extends TEventKey<T>>(hash: HashData, eventName: K, fn: TEventReceiver<T[K]>): void;
-    emit<K extends TEventKey<T>>(hash: HashData, eventName: K, params?: T[K]): void;
+    on<K extends TEventKey<T>>(hash: HashData | '*', eventName: K, fn: TEventReceiver<T[K]>): () => void;
+    off<K extends TEventKey<T>>(hash: HashData | '*', eventName: K, fn: TEventReceiver<T[K]>): void;
+    emit<K extends TEventKey<T>>(hash: HashData | '*', eventName: K, params?: T[K]): void;
 }
 
 /**
@@ -790,20 +790,20 @@ interface IFocusCheck {
     currentInstruction: number;
 }
 declare const focus: {
-    "__#7@#root": HTMLElement;
-    "__#7@#props": IFocusProps | undefined;
+    "__#8@#root": HTMLElement;
+    "__#8@#props": IFocusProps | undefined;
     afterNotificationFocus: IFocusQueryElement | undefined;
-    "__#7@#actualFocusQuery": IFocusQueryElement[];
-    "__#7@#currentInstruction": number;
-    "__#7@#focusDelay": number;
-    "__#7@#focusRetries": number;
-    "__#7@#focusTimeout": number;
-    "__#7@#isIntervalRunning": boolean;
-    "__#7@#focusQuery": IFocusQueryElement[];
-    "__#7@#checkInstruction"(focusCheck: IFocusCheck): boolean;
-    "__#7@#doFocus"(HTMLElement: HTMLElement | TFocusRetriever, focusCheck: IFocusCheck, isLastTry: boolean, configuration?: IOnFocusConfiguration): Promise<false | HTMLElement | null>;
-    "__#7@#resetInterval"(): void;
-    "__#7@#runFocusInterval"(focusElement?: IFocusQueryElement, internalCall?: boolean): Promise<false | HTMLElement>;
+    "__#8@#actualFocusQuery": IFocusQueryElement[];
+    "__#8@#currentInstruction": number;
+    "__#8@#focusDelay": number;
+    "__#8@#focusRetries": number;
+    "__#8@#focusTimeout": number;
+    "__#8@#isIntervalRunning": boolean;
+    "__#8@#focusQuery": IFocusQueryElement[];
+    "__#8@#checkInstruction"(focusCheck: IFocusCheck): boolean;
+    "__#8@#doFocus"(HTMLElement: HTMLElement | TFocusRetriever, focusCheck: IFocusCheck, isLastTry: boolean, configuration?: IOnFocusConfiguration): Promise<false | HTMLElement | null>;
+    "__#8@#resetInterval"(): void;
+    "__#8@#runFocusInterval"(focusElement?: IFocusQueryElement, internalCall?: boolean): Promise<false | HTMLElement>;
     /**
      * Da la instrucción de colocar el foco en el elemento provisto como
      * parámetro una vez que todas las notificaciones se hayan cerrado. En caso
@@ -865,6 +865,71 @@ declare const globalFocus: {
     last(querySelector?: string, omit?: number): HTMLElement | TFocusRetriever | null;
 };
 
+type THistoryCount = {
+    currentStep: number;
+    stepCount: number;
+};
+type THistoryStep<T> = {
+    content: T;
+} & THistoryCount;
+type THistoryStepChange<T> = THistoryCount & THistoryStep<T> & {
+    fromPush?: boolean;
+    hasPrevious: boolean;
+    hasNext: boolean;
+};
+type THistoryConfiguration = {
+    maxLength: number;
+};
+/**
+ * # Cómo usar el historial
+ *
+ * Es muy sencillo: se instancia con un callback que recibirá un método push
+ * cada vez que una ventana se cierre. En esos momentos, el usuario del History
+ * puede hacer push al estado.
+ *
+ * ## La mecánica
+ *
+ * - Instancio la clase y recibo el método push
+ * - Cuando se realizan cambios significativos, llamo al método openWindow
+ * - El método openWindow da una ventana de 350ms antes de llamar al callback
+ * - Si durante esa ventana se vuelve a llamar a openWindow, la ventana se
+ * resetea
+ * - Si al llamar al callback, se hace push al estado, ese estado es propagado
+ * mediante el hook y mediante el evento on('stepChange')
+ *
+ * ## Back y forward
+ *
+ * El back y forward son dos métodos del history que hacen un stepChange y
+ * emiten a través de on('stepChange') y el hook
+ */
+declare class History<T> extends EventEmitter<{
+    stepChange: THistoryStepChange<T>;
+}> {
+    private configuration;
+    private autocloseTimeout;
+    private currentStep;
+    private content;
+    private enabled;
+    private _isOpen;
+    private timeoutMs;
+    constructor(onCloseWindow: (push: (newState: T) => void) => unknown, configuration?: THistoryConfiguration);
+    private closeWindow;
+    private getEvent;
+    private onCloseWindow;
+    private push;
+    private shoutStepChange;
+    hooks: {
+        useCountChange: (onChange: (ev: THistoryStepChange<T>) => unknown) => void;
+    };
+    back: () => void;
+    disable: () => void;
+    enable: () => void;
+    forward: () => void;
+    get isOpen(): boolean;
+    openWindow: () => void;
+    updateConfig: (newConfiguration: Partial<THistoryConfiguration>) => void;
+}
+
 /**
  * Permite reasignar múltiples referencias desde un mismo componente.
  *
@@ -911,6 +976,13 @@ declare function useStateRef<T>(initialState?: T): [
  */
 declare function useUpdateEffect(effect: EffectCallback, deps?: DependencyList): void;
 
+declare function shallowEqual(a: unknown, b: unknown): boolean;
+/**
+ * Compara con shallowEqual todos los ítems de dos arrays
+ */
+declare function shallowCompareArrays(a: unknown[], b: unknown[]): boolean;
+declare function useShallowMemo<T>(creator: () => T, deps: unknown[]): T;
+
 type TMethod<CR> = CR extends (state: any, ...args: infer Action) => any ? (id: TId, ...args: Action) => unknown : () => unknown;
 type TMethods<State extends TMap, K extends any[] = any[]> = Record<string, (setState: TStateManager<State>, ...args: K) => void>;
 type TMethodsMap<OriginalMethods extends TMethods<any>> = {
@@ -1463,6 +1535,202 @@ declare const screenLocker: {
     }[K_2] | undefined): void;
 };
 
+type StatefulStoreUnsuscriber = () => void;
+type StatefulStoreUpdater<Props> = (currentProps: Props) => Props;
+type StatefulStoreUpdateProps<Props> = StatefulStoreUpdater<Props> | Partial<Props>;
+/**
+ * Clase facilitadora del uso de StatefulStore. Es un pequeño almacen que
+ * permite actualizar sus propiedades y sabe cómo sincronizarse con el store de
+ * modo que los cambios se propaguen según corresponda.
+ */
+declare abstract class BasicStoredElement<Props extends Record<string, unknown>> {
+    #private;
+    abstract getId(): TId;
+    onUpdate(cb: () => void): StatefulStoreUnsuscriber;
+    props: Props;
+    constructor(props: Props);
+    protected shoutUpdates: () => void;
+    update(newProps: StatefulStoreUpdateProps<Props>): void;
+    useProps: () => Props;
+}
+/**
+ * Son las acciones de adición del store.
+ */
+type AddActions<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `add${Capitalize<string & P>}`]: (el: T[P]) => void;
+};
+/**
+ * Acciones de vaciado del store.
+ */
+type EmptyActions<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `empty${Capitalize<string & P>}`]: () => void;
+};
+/**
+ * Acciones de removido del store.
+ */
+type RemoveActions<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `remove${Capitalize<string & P>}`]: (id: TId) => void;
+};
+/**
+ * Conjunto de acciones disponibles del store
+ */
+type ActionMethods<T extends Record<string, BasicStoredElement<any>>> = {
+    actions: AddActions<T> & EmptyActions<T> & RemoveActions<T>;
+};
+/**
+ * Método que permite obtener el listado de elementos de un tipo.
+ */
+type GetStateActions<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `get${Capitalize<string & P>}State`]: () => T[P][];
+};
+/**
+ * Método que permite conocer las propiedades de un elemento.
+ */
+type GetItemActions<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `get${Capitalize<string & P>}`]: (id: TId) => T[P];
+};
+type UpdateItemActions<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `update${Capitalize<string & P>}`]: (id: TId, newProps: StatefulStoreUpdateProps<T[P]['props']>) => void;
+};
+/**
+ * Conjunto de métodos que permiten acceder al estado en un momento
+ * determinado.
+ */
+type StateMethods<T extends Record<string, BasicStoredElement<any>>> = {
+    state: GetStateActions<T> & GetItemActions<T> & UpdateItemActions<T>;
+};
+/**
+ * Es el hook encargado de permitir la escucha de listado de elementos y sus
+ * propiedades.
+ */
+type HookUseState<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `use${Capitalize<string & P>}`]: () => T[P][];
+};
+/**
+ * Es el hook encargado de permitir la escucha de listado de elementos
+ */
+type HookUseList<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `use${Capitalize<string & P>}List`]: () => T[P][];
+};
+/**
+ * Es el hook encargado de permitir la escucha de propiedades de un elemento
+ */
+type HookUseStateById<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `use${Capitalize<string & P>}ById`]: (id: TId) => T[P] | undefined;
+};
+/**
+ * Conjunto de hooks del store.
+ */
+type HooksMethods<T extends Record<string, BasicStoredElement<any>>> = {
+    hooks: HookUseState<T> & HookUseStateById<T> & HookUseList<T>;
+};
+/**
+ * Es la suscripción encargada de permitir la escucha de propiedades de un
+ * elemento
+ */
+type SuscribeById<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `change${Capitalize<string & P>}Element`]: (id: TId, cb: (props: T[P]) => unknown) => StatefulStoreUnsuscriber;
+};
+/**
+ * Es la suscripción encaragada de permitir la escucha de cambios en la lista y
+ * las propiedades de sus elementos.
+ */
+type SuscribeToListChange<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `change${Capitalize<string & P>}`]: (cb: (props: T[P][]) => unknown) => StatefulStoreUnsuscriber;
+};
+/**
+ * Es la suscripción encaragada de permitir la escucha de cambios en la
+ * cantidad de elementos de la lista, pero no en las propiedades de los
+ * elementos.
+ */
+type SuscribeToListCountChange<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `change${Capitalize<string & P>}Ammount`]: (cb: (props: T[P][]) => unknown) => StatefulStoreUnsuscriber;
+};
+type SuscribeMethods<T extends Record<string, BasicStoredElement<any>>> = {
+    on: SuscribeById<T> & SuscribeToListChange<T> & SuscribeToListCountChange<T>;
+};
+type InitialStates<T extends Record<string, BasicStoredElement<any>>> = {
+    [P in keyof T as `${string & P}State`]: T[P][];
+};
+/**
+ * Este store permite mantener `N` listados de objetos y por cada tipo de
+ * objeto ofrece métodos para agregar, eliminar, obtener uno, obtener todos y
+ * un hook para conocer el listado en tiempo real.
+ *
+ * **Métodos disponibles**
+ *
+ *  - **action.addXXX**: Agrega un elemento de tipo XXX a la lista.
+ *  - **action.emptyXXX**: Vacía el listado de tipo XXX.
+ *  - **action.removeXXX**: Elimina un elemento de tipo XXX de la lista.
+ *  - **hooks.useXXX**: Permite conocer el listado de elementos y el cambio
+ *  en sus propiedades en tiempo real.
+ *  - **hooks.useXXXById**: Permite conocer los cambios a un elemento de la
+ *  lista en tiempo real.
+ *  - **hooks.useXXXList**: Permite conocer el listado de
+ *  elementos pero no reacciona a los cambios en las propiedades de los
+ *  elementos.
+ *  - **on.changeXXX**: Permite suscribirse al listado de elementos y
+ *  cambios en sus propiedades.
+ *  - **on.changeXXXAmmount**: Permite suscribirse
+ *  al listado de elementos, sin tomar en cuenta el cambio en las propiedades
+ *  de sus items.
+ *  - **on.changeXXXElement**: Permite suscribirse al cambio de
+ *  propiedades de un ítem particular
+ *  - **state.getXXX**: Permite obtener el
+ *  esatdo de un elemento particular de la lista.
+ *  - **state.getXXXState**:
+ *  Permite obtener el estado del listado completo de un tipo de elementos.
+ *  - **state.updateXXX**: Es un atajo para state.getXXX(id).update
+ *
+ * La funcionalidad de actualización se implementa en el objeto almacenado y es
+ * comunicada en forma automática al store, de forma que el store no conoce
+ * solamente cuántos y cuáles elementos hay almacenados, sino que además refleja
+ * en tiempo real el estado de sus propiedades.
+ *
+ * @example
+ *
+    type TPeople = { name: string };
+    class People extends BasicStoredElement<TPeople> {
+      getId(): TId {
+        return this.props.name;
+      }
+    }
+
+    class Schedule extends BasicStoredElement<{ day: string; task: string }>
+    {
+      getId() {
+        return this.props.day;
+      }
+    }
+
+    const r = makeStatefulStore(
+      {
+        people: People.prototype,
+        schedules: Schedule.prototype,
+      },
+      {
+        peopleState: [new People({ name: 'A' }), new People({ name: 'B' })],
+      },
+    );
+
+    const p = r.hooks.usePeople();
+    p[0].props.name;
+
+    r.hooks.usePeople();
+
+    r.actions.removePeople('asdf');
+
+    r.actions.addPeople(new People({ name: 'asdf' }));
+    r.actions.removePeople('asdf');
+
+    r.state.getPeopleState();
+    const pep = r.state.getPeople('asdf')
+
+    const ph = r.hooks.usePeople();
+    const sch = r.hooks.useSchedules();
+ */
+declare function makeStatefulStore<T extends Record<string, BasicStoredElement<any>>>(entries: T, initialStates?: Partial<InitialStates<T>>): ActionMethods<T> & HooksMethods<T> & StateMethods<T> & SuscribeMethods<T>;
+
 declare const persistentStorage: {
     [key: string]: unknown;
     remove(prop: string): unknown;
@@ -1506,4 +1774,4 @@ declare function toBoolean(value: unknown): boolean;
 
 declare const parseXmlAsync: <T>(xml: string) => Promise<T>;
 
-export { EventEmitter, HashedEventEmitter, IOnFocusConfiguration, IParameter, ISetBoundary, PropsSelectorUndefinedObject, PropsStore, TApiaAction, TApiaActions, TApiaCellDefinition, TApiaComplexCell, TApiaFieldPropsObj, TApiaFilter, TApiaFilterOption, TApiaFilterValue, TApiaFormButton, TApiaFormElement, TApiaFormElementOption, TApiaFunction, TApiaFunctionPageInfo, TApiaLoad, TApiaLoadForm, TApiaLoadText, TApiaMessage, TApiaMultiplePossibleValue, TApiaPossibleValue, TApiaRadioPossibleValue, TApiaRowDefinition, TApiaSelectPossibleValue, TApiaSystemMessageObj, TApiaTableFunction, TCallback, TDateFormat, TDispatchCallback, TFieldEvent, TFieldScriptEvent, TFieldScriptEvents, TFieldServerEvent, TFieldServerEvents, TFncParams, TFocusRetriever, TId, TKey, TMap$1 as TMap, TMessage, TModify, TNotificationMessage, TPropsComparator, TPropsConfiguration, TPropsSelector, TRequireOnlyOne, TShortcutBranch, TUpdateFieldConfiguration, 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, IOnFocusConfiguration, IParameter, ISetBoundary, PropsSelectorUndefinedObject, PropsStore, StatefulStoreUpdateProps, StatefulStoreUpdater, TApiaAction, TApiaActions, TApiaCellDefinition, TApiaComplexCell, TApiaFieldPropsObj, TApiaFilter, TApiaFilterOption, TApiaFilterValue, TApiaFormButton, TApiaFormElement, TApiaFormElementOption, TApiaFunction, TApiaFunctionPageInfo, TApiaLoad, TApiaLoadForm, TApiaLoadText, TApiaMessage, TApiaMultiplePossibleValue, TApiaPossibleValue, TApiaRadioPossibleValue, TApiaRowDefinition, TApiaSelectPossibleValue, TApiaSystemMessageObj, TApiaTableFunction, TCallback, TDateFormat, TDispatchCallback, TFieldEvent, TFieldScriptEvent, TFieldScriptEvents, TFieldServerEvent, TFieldServerEvents, TFncParams, TFocusRetriever, THistoryCount, THistoryStep, THistoryStepChange, TId, TKey, TMap$1 as TMap, TMessage, TModify, TNotificationMessage, TPropsComparator, TPropsConfiguration, TPropsSelector, TRequireOnlyOne, TShortcutBranch, TUpdateFieldConfiguration, 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 };