@apia/util 1.0.1 → 2.0.0

package/dist/hooks/useUpdateEffect.js

@@ -0,0 +1,16 @@
+import { useRef, useEffect } from 'react';
+
+function useUpdateEffect(effect, deps) {
+  const hasRunnedForFirstTime = useRef(false);
+  useEffect(() => {
+    if (hasRunnedForFirstTime.current) {
+      return effect();
+    }
+    hasRunnedForFirstTime.current = true;
+    return () => {
+    };
+  }, deps);
+}
+
+export { useUpdateEffect };
+//# sourceMappingURL=useUpdateEffect.js.map

package/dist/hooks/useUpdateEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUpdateEffect.js","sources":["../../src/hooks/useUpdateEffect.ts"],"sourcesContent":["/* eslint-disable react-hooks/exhaustive-deps */\nimport { DependencyList, EffectCallback, useEffect, useRef } from 'react';\n\n/**\n * Este hook se comporta igual que useEffect, con la diferencia de que en el\n * primer renderizado no se va a ejecutar.\n */\nexport function useUpdateEffect(effect: EffectCallback, deps?: DependencyList) {\n  const hasRunnedForFirstTime = useRef(false);\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  useEffect(() => {\n    if (hasRunnedForFirstTime.current) {\n      return effect();\n    }\n    hasRunnedForFirstTime.current = true;\n    return () => {};\n  }, deps);\n}\n"],"names":[],"mappings":";;AAOgB,SAAA,eAAA,CAAgB,QAAwB,IAAuB,EAAA;AAC7E,EAAM,MAAA,qBAAA,GAAwB,OAAO,KAAK,CAAA,CAAA;AAE1C,EAAA,SAAA,CAAU,MAAM;AACd,IAAA,IAAI,sBAAsB,OAAS,EAAA;AACjC,MAAA,OAAO,MAAO,EAAA,CAAA;AAAA,KAChB;AACA,IAAA,qBAAA,CAAsB,OAAU,GAAA,IAAA,CAAA;AAChC,IAAA,OAAO,MAAM;AAAA,KAAC,CAAA;AAAA,KACb,IAAI,CAAA,CAAA;AACT;;;;"}

package/dist/imperative/makeImperativeComponent.d.ts

@@ -0,0 +1,56 @@
+import { FC } from 'react';
+import { TMap, TMethods, TMethodsMap, TFireEvent } from './types.js';
+import { TId } from '../types/misc.js';
+
+/**
+ * Permite la creación de componentes multi-instancia que ofrecen métodos para
+ * trabajar sobre su estado o su comportamiento interno.
+ *
+ * @example
+ * const [methods, events, Imperative] = makeImperativeComponent<
+    {
+      age: number;
+    },
+    { blink: number }
+  >()(
+    {} as {
+      name: string;
+    },
+    {
+      setName(setState, name: string) {
+        setState({ name });
+      },
+    },
+    ({ age, name, useEvents }) => {
+      const [isBlinking, setIsBlinking] = useState(false);
+
+      useEvents({
+        blink() {
+          setInterval(() => setIsBlinking((current) => !current), 300);
+        },
+      });
+
+      return (
+        <Box sx={{ background: isBlinking ? 'red' : undefined }}>
+          {age} {name}
+        </Box>
+      );
+    },
+  );
+
+  methods
+ */
+declare function makeImperativeComponent<ComponentProps extends TMap, Events extends TMap = TMap>(): <State extends TMap, Methods extends TMethods<State>>({ Component, initialState, methods, }: {
+    initialState?: State | undefined;
+    methods?: Methods | undefined;
+    Component: FC<Omit<ComponentProps, 'id'> & State>;
+}) => [
+    TMethodsMap<Methods>,
+    TFireEvent<Events>,
+    FC<ComponentProps & {
+        id: TId;
+    }>
+];
+
+export { makeImperativeComponent as default };
+//# sourceMappingURL=makeImperativeComponent.d.ts.map

package/dist/imperative/makeImperativeComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeImperativeComponent.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/imperative/makeImperativeComponent.js

@@ -0,0 +1,48 @@
+import { jsx } from 'react/jsx-runtime';
+import { useState, useMemo } from 'react';
+import { ImperativeComponentContext } from './types.js';
+
+function makeImperativeComponent() {
+  return function ImperativeComponent({
+    Component,
+    initialState,
+    methods
+  }) {
+    const setStates = {};
+    const actualMethods = {};
+    Object.entries(methods ?? {}).forEach(([key, method]) => {
+      actualMethods[key] = (id, ...args) => {
+        if (setStates[id])
+          method(setStates[id], ...args);
+        else {
+          console.warn(`The requested id does not exist: ${id}`);
+        }
+      };
+    });
+    const eventsHandlers = {};
+    const fireEvent = (id, ev, args) => {
+      if (eventsHandlers[id])
+        eventsHandlers[id]?.[ev]?.forEach((current) => current.cb(args));
+      else
+        console.warn(`The requested id does not exist: ${id}`);
+    };
+    const ActualComponent = ({
+      id,
+      ...props
+    }) => {
+      const [state, innerSetState] = useState(initialState);
+      setStates[id] = (newState) => innerSetState((current) => ({ ...current, ...newState }));
+      return /* @__PURE__ */ jsx(
+        ImperativeComponentContext.Provider,
+        {
+          value: useMemo(() => ({ id, eventsStore: eventsHandlers }), [id]),
+          children: /* @__PURE__ */ jsx(Component, { ...props, ...state })
+        }
+      );
+    };
+    return [actualMethods, fireEvent, ActualComponent];
+  };
+}
+
+export { makeImperativeComponent as default };
+//# sourceMappingURL=makeImperativeComponent.js.map

package/dist/imperative/makeImperativeComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeImperativeComponent.js","sources":["../../src/imperative/makeImperativeComponent.tsx"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/no-unsafe-argument */\nimport { FC, useMemo, useState } from 'react';\nimport {\n  TMap,\n  TMethods,\n  TMethodsMap,\n  TFireEvent,\n  TStateManager,\n  TMethod,\n  TEventsHandlers,\n  ImperativeComponentContext,\n} from './types';\nimport { TId } from '../types';\n\n/**\n * Permite la creación de componentes multi-instancia que ofrecen métodos para\n * trabajar sobre su estado o su comportamiento interno.\n * \n * @example\n * const [methods, events, Imperative] = makeImperativeComponent<\n    {\n      age: number;\n    },\n    { blink: number }\n  >()(\n    {} as {\n      name: string;\n    },\n    {\n      setName(setState, name: string) {\n        setState({ name });\n      },\n    },\n    ({ age, name, useEvents }) => {\n      const [isBlinking, setIsBlinking] = useState(false);\n\n      useEvents({\n        blink() {\n          setInterval(() => setIsBlinking((current) => !current), 300);\n        },\n      });\n\n      return (\n        <Box sx={{ background: isBlinking ? 'red' : undefined }}>\n          {age} {name}\n        </Box>\n      );\n    },\n  );\n\n  methods\n */\nexport default function makeImperativeComponent<\n  ComponentProps extends TMap,\n  Events extends TMap = TMap,\n>() {\n  return function ImperativeComponent<\n    State extends TMap,\n    Methods extends TMethods<State>,\n  >({\n    Component,\n    initialState,\n    methods,\n  }: {\n    initialState?: State;\n    methods?: Methods;\n    Component: FC<Omit<ComponentProps, 'id'> & State>;\n  }): [\n    TMethodsMap<Methods>,\n    TFireEvent<Events>,\n    FC<ComponentProps & { id: TId }>,\n  ] {\n    /**\n     * State methods\n     */\n\n    const setStates: Record<string, TStateManager<State>> = {};\n    const actualMethods: TMethodsMap<Methods> = {} as TMethodsMap<Methods>;\n    Object.entries(methods ?? {}).forEach(([key, method]) => {\n      actualMethods[key as keyof Methods] = ((id, ...args: any) => {\n        if (setStates[id]) method(setStates[id], ...args);\n        else {\n          console.warn(`The requested id does not exist: ${id}`);\n        }\n      }) as TMethod<Methods[keyof Methods]>;\n    });\n\n    /**\n     * Events\n     */\n    const eventsHandlers: TEventsHandlers<Events> = {};\n\n    const fireEvent: TFireEvent<Events> = <K extends keyof Events>(\n      id: TId,\n      ev: K,\n      args?: Events[K],\n    ) => {\n      if (eventsHandlers[id])\n        eventsHandlers[id]?.[ev]?.forEach((current) => current.cb(args));\n      else console.warn(`The requested id does not exist: ${id}`);\n    };\n\n    /**\n     * Component\n     */\n\n    const ActualComponent: FC<ComponentProps & { id: TId }> = ({\n      id,\n      ...props\n    }) => {\n      const [state, innerSetState] = useState(initialState as State);\n\n      setStates[id] = (newState) =>\n        innerSetState((current) => ({ ...current, ...newState }));\n\n      return (\n        <ImperativeComponentContext.Provider\n          value={useMemo(() => ({ id, eventsStore: eventsHandlers }), [id])}\n        >\n          <Component {...props} {...state} />\n        </ImperativeComponentContext.Provider>\n      );\n    };\n\n    return [actualMethods, fireEvent, ActualComponent];\n  };\n}\n"],"names":[],"mappings":";;;;AAqDA,SAAwB,uBAGpB,GAAA;AACF,EAAA,OAAO,SAAS,mBAGd,CAAA;AAAA,IACA,SAAA;AAAA,IACA,YAAA;AAAA,IACA,OAAA;AAAA,GASA,EAAA;AAKA,IAAA,MAAM,YAAkD,EAAC,CAAA;AACzD,IAAA,MAAM,gBAAsC,EAAC,CAAA;AAC7C,IAAO,MAAA,CAAA,OAAA,CAAQ,OAAW,IAAA,EAAE,CAAA,CAAE,QAAQ,CAAC,CAAC,GAAK,EAAA,MAAM,CAAM,KAAA;AACvD,MAAA,aAAA,CAAc,GAAoB,CAAA,GAAK,CAAC,EAAA,EAAA,GAAO,IAAc,KAAA;AAC3D,QAAA,IAAI,UAAU,EAAE,CAAA;AAAG,UAAA,MAAA,CAAO,SAAU,CAAA,EAAE,CAAG,EAAA,GAAG,IAAI,CAAA,CAAA;AAAA,aAC3C;AACH,UAAQ,OAAA,CAAA,IAAA,CAAK,CAAoC,iCAAA,EAAA,EAAE,CAAE,CAAA,CAAA,CAAA;AAAA,SACvD;AAAA,OACF,CAAA;AAAA,KACD,CAAA,CAAA;AAKD,IAAA,MAAM,iBAA0C,EAAC,CAAA;AAEjD,IAAA,MAAM,SAAgC,GAAA,CACpC,EACA,EAAA,EAAA,EACA,IACG,KAAA;AACH,MAAA,IAAI,eAAe,EAAE,CAAA;AACnB,QAAe,cAAA,CAAA,EAAE,CAAI,GAAA,EAAE,CAAG,EAAA,OAAA,CAAQ,CAAC,OAAY,KAAA,OAAA,CAAQ,EAAG,CAAA,IAAI,CAAC,CAAA,CAAA;AAAA;AAC5D,QAAQ,OAAA,CAAA,IAAA,CAAK,CAAoC,iCAAA,EAAA,EAAE,CAAE,CAAA,CAAA,CAAA;AAAA,KAC5D,CAAA;AAMA,IAAA,MAAM,kBAAoD,CAAC;AAAA,MACzD,EAAA;AAAA,MACA,GAAG,KAAA;AAAA,KACC,KAAA;AACJ,MAAA,MAAM,CAAC,KAAA,EAAO,aAAa,CAAA,GAAI,SAAS,YAAqB,CAAA,CAAA;AAE7D,MAAA,SAAA,CAAU,EAAE,CAAA,GAAI,CAAC,QAAA,KACf,aAAc,CAAA,CAAC,OAAa,MAAA,EAAE,GAAG,OAAA,EAAS,GAAG,QAAA,EAAW,CAAA,CAAA,CAAA;AAE1D,MACE,uBAAA,GAAA;AAAA,QAAC,0BAA2B,CAAA,QAAA;AAAA,QAA3B;AAAA,UACC,KAAA,EAAO,OAAQ,CAAA,OAAO,EAAE,EAAA,EAAI,aAAa,cAAe,EAAA,CAAA,EAAI,CAAC,EAAE,CAAC,CAAA;AAAA,UAEhE,QAAC,kBAAA,GAAA,CAAA,SAAA,EAAA,EAAW,GAAG,KAAA,EAAQ,GAAG,KAAO,EAAA,CAAA;AAAA,SAAA;AAAA,OACnC,CAAA;AAAA,KAEJ,CAAA;AAEA,IAAO,OAAA,CAAC,aAAe,EAAA,SAAA,EAAW,eAAe,CAAA,CAAA;AAAA,GACnD,CAAA;AACF;;;;"}

package/dist/imperative/makeSingleImperativeComponent.d.ts

@@ -0,0 +1,15 @@
+import { FC } from 'react';
+import { TMap, TMethods, TMethodsMap } from './types.js';
+import { TId } from '../types/misc.js';
+
+type TSingleMethodsMap<Methods extends TMethods<any>, MethodsMap extends TMethodsMap<Methods>> = {
+    [Name in keyof MethodsMap]: MethodsMap[Name] extends (id: TId, ...args: infer Action) => unknown ? (...args: Action) => unknown : never;
+};
+declare function makeSingleImperativeComponent<ComponentProps extends TMap, Events extends TMap = TMap>(): <State extends TMap, Methods extends TMethods<State>>({ initialState, methods, Component, }: {
+    initialState?: State | undefined;
+    methods?: Methods | undefined;
+    Component: FC<Omit<ComponentProps, 'id'> & State>;
+}) => [TSingleMethodsMap<Methods, TMethodsMap<Methods>>, <K extends keyof Events>(ev: K, args: Events[K]) => void, FC<ComponentProps>];
+
+export { makeSingleImperativeComponent as default };
+//# sourceMappingURL=makeSingleImperativeComponent.d.ts.map

package/dist/imperative/makeSingleImperativeComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeSingleImperativeComponent.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/imperative/makeSingleImperativeComponent.js

@@ -0,0 +1,31 @@
+import { jsx } from 'react/jsx-runtime';
+import uniqueId from 'lodash-es/uniqueId';
+import makeImperativeComponent from './makeImperativeComponent.js';
+
+function makeSingleImperativeComponent() {
+  return function SingleImperativeComponent({
+    initialState,
+    methods,
+    Component
+  }) {
+    const id = uniqueId();
+    const [actualMethods, originalFireEvent, ImperativeComponent] = makeImperativeComponent()({
+      initialState,
+      methods,
+      Component
+    });
+    const fireEvent = (ev, args) => originalFireEvent(id, ev, args);
+    const newMethods = {};
+    Object.entries(actualMethods).forEach(([name, method]) => {
+      newMethods[name] = (...args) => method(id, ...args);
+    });
+    return [
+      newMethods,
+      fireEvent,
+      (props) => /* @__PURE__ */ jsx(ImperativeComponent, { ...props, id })
+    ];
+  };
+}
+
+export { makeSingleImperativeComponent as default };
+//# sourceMappingURL=makeSingleImperativeComponent.js.map

package/dist/imperative/makeSingleImperativeComponent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeSingleImperativeComponent.js","sources":["../../src/imperative/makeSingleImperativeComponent.tsx"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unsafe-argument */\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { FC } from 'react';\nimport uniqueId from 'lodash-es/uniqueId';\nimport { TMap, TMethods, TMethodsMap } from './types';\nimport makeImperativeComponent from './makeImperativeComponent';\nimport { TId } from '../types';\n\ntype TSingleMethodsMap<\n  Methods extends TMethods<any>,\n  MethodsMap extends TMethodsMap<Methods>,\n> = {\n  [Name in keyof MethodsMap]: MethodsMap[Name] extends (\n    id: TId,\n    ...args: infer Action\n  ) => unknown\n    ? (...args: Action) => unknown\n    : never;\n};\n\nexport default function makeSingleImperativeComponent<\n  ComponentProps extends TMap,\n  Events extends TMap = TMap,\n>() {\n  return function SingleImperativeComponent<\n    State extends TMap,\n    Methods extends TMethods<State>,\n  >({\n    initialState,\n    methods,\n    Component,\n  }: {\n    initialState?: State;\n    methods?: Methods;\n    Component: FC<Omit<ComponentProps, 'id'> & State>;\n  }): [\n    TSingleMethodsMap<Methods, TMethodsMap<Methods>>,\n    <K extends keyof Events>(ev: K, args: Events[K]) => void,\n    FC<ComponentProps>,\n  ] {\n    const id = uniqueId();\n\n    const [actualMethods, originalFireEvent, ImperativeComponent] =\n      makeImperativeComponent<ComponentProps, Events>()({\n        initialState,\n        methods,\n        Component,\n      });\n\n    const fireEvent: <K extends keyof Events>(\n      ev: K,\n      args: Events[K],\n    ) => void = (ev, args) => originalFireEvent(id, ev, args);\n\n    const newMethods: TSingleMethodsMap<\n      Methods,\n      TMethodsMap<Methods>\n    > = {} as TSingleMethodsMap<Methods, TMethodsMap<Methods>>;\n\n    Object.entries(actualMethods).forEach(([name, method]) => {\n      (newMethods[name as keyof typeof newMethods] as any) = (...args: any) =>\n        (method as (id: TId, ...args: any) => unknown)(id, ...args);\n    });\n\n    return [\n      newMethods,\n      fireEvent,\n      (props: ComponentProps) => <ImperativeComponent {...props} id={id} />,\n    ];\n  };\n}\n"],"names":[],"mappings":";;;;AAoBA,SAAwB,6BAGpB,GAAA;AACF,EAAA,OAAO,SAAS,yBAGd,CAAA;AAAA,IACA,YAAA;AAAA,IACA,OAAA;AAAA,IACA,SAAA;AAAA,GASA,EAAA;AACA,IAAA,MAAM,KAAK,QAAS,EAAA,CAAA;AAEpB,IAAA,MAAM,CAAC,aAAe,EAAA,iBAAA,EAAmB,mBAAmB,CAAA,GAC1D,yBAAkD,CAAA;AAAA,MAChD,YAAA;AAAA,MACA,OAAA;AAAA,MACA,SAAA;AAAA,KACD,CAAA,CAAA;AAEH,IAAA,MAAM,YAGM,CAAC,EAAA,EAAI,SAAS,iBAAkB,CAAA,EAAA,EAAI,IAAI,IAAI,CAAA,CAAA;AAExD,IAAA,MAAM,aAGF,EAAC,CAAA;AAEL,IAAO,MAAA,CAAA,OAAA,CAAQ,aAAa,CAAE,CAAA,OAAA,CAAQ,CAAC,CAAC,IAAA,EAAM,MAAM,CAAM,KAAA;AACxD,MAAC,UAAA,CAAW,IAA+B,CAAY,GAAA,CAAA,GAAI,SACxD,MAA8C,CAAA,EAAA,EAAI,GAAG,IAAI,CAAA,CAAA;AAAA,KAC7D,CAAA,CAAA;AAED,IAAO,OAAA;AAAA,MACL,UAAA;AAAA,MACA,SAAA;AAAA,MACA,CAAC,KAA0B,qBAAA,GAAA,CAAC,mBAAqB,EAAA,EAAA,GAAG,OAAO,EAAQ,EAAA,CAAA;AAAA,KACrE,CAAA;AAAA,GACF,CAAA;AACF;;;;"}

package/dist/imperative/types.d.ts

@@ -0,0 +1,22 @@
+import { TId } from '../types/misc.js';
+
+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>> = {
+    [Name in keyof OriginalMethods]: TMethod<OriginalMethods[Name]>;
+};
+type TEventsMap<OriginalEvents extends TMap> = {
+    [Name in keyof OriginalEvents]: (args: OriginalEvents[Name]) => unknown;
+};
+type TEventsHandlers<OriginalEvents extends TMap> = Record<TId, {
+    [Name in keyof OriginalEvents]?: {
+        cb: (args?: OriginalEvents[Name]) => unknown;
+        uniqueHookId: string;
+    }[];
+}>;
+type TMap = Record<string, any>;
+type TStateManager<State> = (newState: Partial<State>) => void;
+type TFireEvent<Events extends TMap> = <K extends keyof Events>(id: TId, ev: K, args: Events[K] extends void ? undefined : Events[K]) => void;
+
+export type { TEventsHandlers, TEventsMap, TFireEvent, TMap, TMethod, TMethods, TMethodsMap, TStateManager };
+//# sourceMappingURL=types.d.ts.map

package/dist/imperative/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/imperative/types.js

@@ -0,0 +1,8 @@
+import { createContext } from 'react';
+
+const ImperativeComponentContext = createContext(
+  {}
+);
+
+export { ImperativeComponentContext };
+//# sourceMappingURL=types.js.map

package/dist/imperative/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":["../../src/imperative/types.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { createContext } from 'react';\nimport { TId } from '../types';\n\nexport type TMethod<CR> = CR extends (state: any, ...args: infer Action) => any\n  ? (id: TId, ...args: Action) => unknown\n  : () => unknown;\n\nexport type TMethods<State extends TMap, K extends any[] = any[]> = Record<\n  string,\n  (setState: TStateManager<State>, ...args: K) => void\n>;\n\nexport type TMethodsMap<OriginalMethods extends TMethods<any>> = {\n  [Name in keyof OriginalMethods]: TMethod<OriginalMethods[Name]>;\n};\n\nexport type TEventsMap<OriginalEvents extends TMap> = {\n  [Name in keyof OriginalEvents]: (args: OriginalEvents[Name]) => unknown;\n};\n\nexport type TEventsHandlers<OriginalEvents extends TMap> = Record<\n  TId,\n  {\n    [Name in keyof OriginalEvents]?: {\n      cb: (args?: OriginalEvents[Name]) => unknown;\n      uniqueHookId: string;\n    }[];\n  }\n>;\n\nexport type TMap = Record<string, any>;\n\nexport type TStateManager<State> = (newState: Partial<State>) => void;\n\nexport type TUseEvents<Events extends TMap> = (\n  handlers: Partial<TEventsMap<Events>>,\n) => void;\n\nexport const ImperativeComponentContext = createContext<{\n  id: TId;\n  eventsStore: TEventsHandlers<any>;\n}>(\n  {} as {\n    id: TId;\n    eventsStore: TEventsHandlers<any>;\n  },\n);\n\nexport type TFireEvent<Events extends TMap> = <K extends keyof Events>(\n  id: TId,\n  ev: K,\n  args: Events[K] extends void ? undefined : Events[K],\n) => void;\n"],"names":[],"mappings":";;AAuCO,MAAM,0BAA6B,GAAA,aAAA;AAAA,EAIxC,EAAC;AAIH;;;;"}

package/dist/imperative/useImperativeComponentEvents.d.ts

@@ -0,0 +1,6 @@
+import { TMap, TEventsMap } from './types.js';
+
+declare const useImperativeComponentEvents: <Events extends TMap = TMap>(handlers: Partial<TEventsMap<Events>>) => string;
+
+export { useImperativeComponentEvents as default };
+//# sourceMappingURL=useImperativeComponentEvents.d.ts.map

package/dist/imperative/useImperativeComponentEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useImperativeComponentEvents.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/imperative/useImperativeComponentEvents.js

@@ -0,0 +1,35 @@
+import { useMemo, useRef, useCallback, useEffect } from 'react';
+import useImperativeComponentContext from './useImperativeIdentifierContext.js';
+import uniqueId from 'lodash-es/uniqueId';
+
+const useImperativeComponentEvents = (handlers) => {
+  const uniqueHookId = useMemo(() => uniqueId("hook"), []);
+  const { id, eventsStore } = useImperativeComponentContext();
+  const hasRegistered = useRef(false);
+  const registerEvents = useCallback(() => {
+    Object.entries(handlers).forEach(([name, callback]) => {
+      if (!eventsStore[id])
+        eventsStore[id] = {};
+      if (!eventsStore[id][name])
+        eventsStore[id][name] = [];
+      eventsStore[id][name]?.push({
+        cb: callback,
+        uniqueHookId
+      });
+    });
+  }, [eventsStore, handlers, id, uniqueHookId]);
+  useEffect(() => {
+    registerEvents();
+    return () => {
+      hasRegistered.current = false;
+      Object.entries(handlers).forEach(([name]) => {
+        eventsStore[id][name] = (eventsStore[id][name] ?? []).filter((current) => current.uniqueHookId !== uniqueHookId);
+      });
+    };
+  }, [eventsStore, handlers, id, registerEvents, uniqueHookId]);
+  return uniqueHookId;
+};
+var useImperativeComponentEvents$1 = useImperativeComponentEvents;
+
+export { useImperativeComponentEvents$1 as default };
+//# sourceMappingURL=useImperativeComponentEvents.js.map

package/dist/imperative/useImperativeComponentEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useImperativeComponentEvents.js","sources":["../../src/imperative/useImperativeComponentEvents.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unsafe-argument */\nimport { useCallback, useEffect, useMemo, useRef } from 'react';\nimport { TEventsMap, TMap } from './types';\nimport useImperativeComponentContext from './useImperativeIdentifierContext';\nimport uniqueId from 'lodash-es/uniqueId';\n\nconst useImperativeComponentEvents = <Events extends TMap = TMap>(\n  handlers: Partial<TEventsMap<Events>>,\n) => {\n  const uniqueHookId = useMemo(() => uniqueId('hook'), []);\n\n  const { id, eventsStore } = useImperativeComponentContext<Events>();\n  const hasRegistered = useRef(false);\n\n  const registerEvents = useCallback(() => {\n    Object.entries(handlers).forEach(([name, callback]) => {\n      if (!eventsStore[id]) eventsStore[id] = {};\n      if (!eventsStore[id][name])\n        eventsStore[id][name as keyof (typeof eventsStore)[typeof id]] = [];\n\n      eventsStore[id][name as keyof (typeof eventsStore)[typeof id]]?.push({\n        cb: callback as (args?: Events[keyof Events] | undefined) => unknown,\n        uniqueHookId: uniqueHookId,\n      });\n    });\n  }, [eventsStore, handlers, id, uniqueHookId]);\n\n  useEffect(() => {\n    registerEvents();\n    return () => {\n      hasRegistered.current = false;\n      Object.entries(handlers).forEach(([name]) => {\n        eventsStore[id][name as keyof (typeof eventsStore)[typeof id]] = (\n          eventsStore[id][name as keyof (typeof eventsStore)[typeof id]] ?? []\n        ).filter((current) => current.uniqueHookId !== uniqueHookId);\n      });\n    };\n  }, [eventsStore, handlers, id, registerEvents, uniqueHookId]);\n\n  return uniqueHookId;\n};\n\nexport default useImperativeComponentEvents;\n"],"names":[],"mappings":";;;;AAMA,MAAM,4BAAA,GAA+B,CACnC,QACG,KAAA;AACH,EAAA,MAAM,eAAe,OAAQ,CAAA,MAAM,SAAS,MAAM,CAAA,EAAG,EAAE,CAAA,CAAA;AAEvD,EAAA,MAAM,EAAE,EAAA,EAAI,WAAY,EAAA,GAAI,6BAAsC,EAAA,CAAA;AAClE,EAAM,MAAA,aAAA,GAAgB,OAAO,KAAK,CAAA,CAAA;AAElC,EAAM,MAAA,cAAA,GAAiB,YAAY,MAAM;AACvC,IAAO,MAAA,CAAA,OAAA,CAAQ,QAAQ,CAAE,CAAA,OAAA,CAAQ,CAAC,CAAC,IAAA,EAAM,QAAQ,CAAM,KAAA;AACrD,MAAI,IAAA,CAAC,YAAY,EAAE,CAAA;AAAG,QAAY,WAAA,CAAA,EAAE,IAAI,EAAC,CAAA;AACzC,MAAA,IAAI,CAAC,WAAA,CAAY,EAAE,CAAA,CAAE,IAAI,CAAA;AACvB,QAAA,WAAA,CAAY,EAAE,CAAA,CAAE,IAA6C,CAAA,GAAI,EAAC,CAAA;AAEpE,MAAA,WAAA,CAAY,EAAE,CAAA,CAAE,IAA6C,CAAA,EAAG,IAAK,CAAA;AAAA,QACnE,EAAI,EAAA,QAAA;AAAA,QACJ,YAAA;AAAA,OACD,CAAA,CAAA;AAAA,KACF,CAAA,CAAA;AAAA,KACA,CAAC,WAAA,EAAa,QAAU,EAAA,EAAA,EAAI,YAAY,CAAC,CAAA,CAAA;AAE5C,EAAA,SAAA,CAAU,MAAM;AACd,IAAe,cAAA,EAAA,CAAA;AACf,IAAA,OAAO,MAAM;AACX,MAAA,aAAA,CAAc,OAAU,GAAA,KAAA,CAAA;AACxB,MAAA,MAAA,CAAO,QAAQ,QAAQ,CAAA,CAAE,QAAQ,CAAC,CAAC,IAAI,CAAM,KAAA;AAC3C,QAAA,WAAA,CAAY,EAAE,CAAE,CAAA,IAA6C,CAC3D,GAAA,CAAA,WAAA,CAAY,EAAE,CAAE,CAAA,IAA6C,CAAK,IAAA,IAClE,MAAO,CAAA,CAAC,OAAY,KAAA,OAAA,CAAQ,iBAAiB,YAAY,CAAA,CAAA;AAAA,OAC5D,CAAA,CAAA;AAAA,KACH,CAAA;AAAA,KACC,CAAC,WAAA,EAAa,UAAU,EAAI,EAAA,cAAA,EAAgB,YAAY,CAAC,CAAA,CAAA;AAE5D,EAAO,OAAA,YAAA,CAAA;AACT,CAAA,CAAA;AAEA,qCAAe,4BAAA;;;;"}

package/dist/imperative/useImperativeIdentifierContext.d.ts

@@ -0,0 +1,14 @@
+import { TMap, TEventsHandlers } from './types.js';
+import { TId } from '../types/misc.js';
+
+/**
+ * Permite el uso de eventos en herederos directos o no del imperativeComponent
+ * más cercano.
+ */
+declare function useImperativeComponentContext<Events extends TMap = TMap>(): {
+    id: TId;
+    eventsStore: TEventsHandlers<Events>;
+};
+
+export { useImperativeComponentContext as default };
+//# sourceMappingURL=useImperativeIdentifierContext.d.ts.map

package/dist/imperative/useImperativeIdentifierContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useImperativeIdentifierContext.d.ts","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/imperative/useImperativeIdentifierContext.js

@@ -0,0 +1,10 @@
+import { useContext } from 'react';
+import { ImperativeComponentContext } from './types.js';
+
+function useImperativeComponentContext() {
+  const context = useContext(ImperativeComponentContext);
+  return context;
+}
+
+export { useImperativeComponentContext as default };
+//# sourceMappingURL=useImperativeIdentifierContext.js.map

package/dist/imperative/useImperativeIdentifierContext.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useImperativeIdentifierContext.js","sources":["../../src/imperative/useImperativeIdentifierContext.ts"],"sourcesContent":["import { useContext } from 'react';\nimport { ImperativeComponentContext, TEventsHandlers, TMap } from './types';\nimport { TId } from '../types';\n\n/**\n * Permite el uso de eventos en herederos directos o no del imperativeComponent\n * más cercano.\n */\nexport default function useImperativeComponentContext<\n  Events extends TMap = TMap,\n>() {\n  const context = useContext(ImperativeComponentContext) as {\n    id: TId;\n    eventsStore: TEventsHandlers<Events>;\n  };\n\n  return context;\n}\n"],"names":[],"mappings":";;;AAQA,SAAwB,6BAEpB,GAAA;AACF,EAAM,MAAA,OAAA,GAAU,WAAW,0BAA0B,CAAA,CAAA;AAKrD,EAAO,OAAA,OAAA,CAAA;AACT;;;;"}