@zydon/common 2.5.42 → 2.5.43

package/dist/theme/styles/index.d.ts

@@ -443,7 +443,7 @@ declare function paper({ theme, color, dropdown }: PaperProps): {
     wordWrap?: csstype.Property.WordWrap | readonly NonNullable<csstype.Property.WordWrap | undefined>[] | readonly csstype.Property.WordWrap[] | undefined;
     writingMode?: csstype.Property.WritingMode | readonly NonNullable<csstype.Property.WritingMode | undefined>[] | readonly csstype.Property.WritingMode[] | undefined;
     zIndex?: csstype.Property.ZIndex | readonly NonNullable<csstype.Property.ZIndex | undefined>[] | readonly ((string & {}) | csstype.Globals | "auto")[] | undefined;
-    zoom?: csstype.Property.Zoom | readonly NonNullable<csstype.Property.Zoom | undefined>[] | readonly ("reset" | (string & {}) | csstype.Globals | "normal")[] | undefined;
+    zoom?: csstype.Property.Zoom | readonly NonNullable<csstype.Property.Zoom | undefined>[] | readonly ((string & {}) | csstype.Globals | "normal" | "reset")[] | undefined;
     all?: csstype.Globals | readonly NonNullable<csstype.Globals | undefined>[] | readonly csstype.Globals[] | undefined;
     animation?: csstype.Property.Animation<string & {}> | readonly NonNullable<csstype.Property.Animation<string & {}> | undefined>[] | readonly ((string & {}) | csstype.Globals | "normal" | "reverse" | "auto" | "none" | "both" | "alternate" | "alternate-reverse" | "backwards" | "forwards" | "infinite" | "paused" | "running" | "ease" | "ease-in" | "ease-in-out" | "ease-out" | "step-end" | "step-start" | "linear")[] | undefined;
     animationRange?: csstype.Property.AnimationRange<string | number> | readonly NonNullable<csstype.Property.AnimationRange<string | number> | undefined>[] | readonly (string | (string & {}))[] | undefined;

package/dist/utils/execution.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Executa imediatamente uma função e retorna seu resultado.
+ *
+ * Esta função utilitária é usada para avaliar expressões de forma "eager" (ansiosa),
+ * executando a função fornecida imediatamente e retornando seu valor. É útil em
+ * situações onde você quer forçar a execução imediata de uma função que poderia
+ * ser avaliada de forma lazy (preguiçosa).
+ *
+ * @template T - O tipo do valor retornado pela função
+ * @param fn - A função a ser executada imediatamente
+ * @returns O resultado da execução da função
+ *
+ * @example
+ * ```typescript
+ * // Execução imediata de uma computação
+ * const result = eager(() => {
+ *   console.log('Executando agora!');
+ *   return 42;
+ * }); // result = 42, e o console.log é executado imediatamente
+ *
+ * // Útil para inicialização de valores
+ * const config = eager(() => ({
+ *   apiUrl: process.env.API_URL || 'http://localhost:3000',
+ *   timeout: 5000
+ * }));
+ *
+ * // Forçar execução de side effects
+ * eager(() => {
+ *   localStorage.setItem('initialized', 'true');
+ *   return null;
+ * });
+ * ```
+ */
+declare const eager: <T>(fn: () => T) => T;
+/**
+ * Adia a execução de uma função para o próximo ciclo do event loop.
+ *
+ * Esta função utiliza setTimeout com delay 0 para agendar a execução da função
+ * fornecida para o próximo tick do event loop. É útil para quebrar operações
+ * síncronas longas ou para garantir que o DOM seja atualizado antes da execução.
+ *
+ * @template T - O tipo do valor retornado pela função
+ * @param fn - A função a ser executada de forma adiada
+ * @returns Uma Promise que resolve com o resultado da função
+ *
+ * @example
+ * ```typescript
+ * // Adiar execução para permitir atualização do DOM
+ * const updateUI = async () => {
+ *   setLoading(true);
+ *
+ *   const result = await defer(() => {
+ *     return processLargeDataset(data);
+ *   });
+ *
+ *   setLoading(false);
+ *   return result;
+ * };
+ *
+ * // Quebrar operação síncrona longa
+ * const processInChunks = async (items: any[]) => {
+ *   for (let i = 0; i < items.length; i += 100) {
+ *     const chunk = items.slice(i, i + 100);
+ *     processChunk(chunk);
+ *
+ *     // Permite que outras tarefas sejam executadas
+ *     await defer(() => {});
+ *   }
+ * };
+ * ```
+ */
+declare const defer: <T>(fn: () => T) => Promise<T>;
+/**
+ * Cria uma versão debounced de uma função que atrasa sua execução até que
+ * tenha passado um determinado tempo desde a última vez que foi invocada.
+ *
+ * Esta função é útil para limitar a frequência de execução de funções caras
+ * computacionalmente, como chamadas de API, validações ou atualizações de UI
+ * em resposta a eventos frequentes como digitação ou scroll.
+ *
+ * @template T - O tipo dos argumentos da função
+ * @template R - O tipo do valor retornado pela função
+ * @param fn - A função a ser debounced
+ * @param delay - O tempo em milissegundos para aguardar antes da execução
+ * @returns Uma versão debounced da função original
+ *
+ * @example
+ * ```typescript
+ * // Debounce para busca em tempo real
+ * const searchAPI = debounce(async (query: string) => {
+ *   const results = await fetch(`/api/search?q=${query}`);
+ *   return results.json();
+ * }, 300);
+ *
+ * // Uso em input de busca
+ * const handleSearchInput = (event: ChangeEvent<HTMLInputElement>) => {
+ *   searchAPI(event.target.value);
+ * };
+ *
+ * // Debounce para redimensionamento de janela
+ * const handleResize = debounce(() => {
+ *   console.log('Janela redimensionada:', window.innerWidth);
+ *   updateLayout();
+ * }, 250);
+ *
+ * window.addEventListener('resize', handleResize);
+ *
+ * // Debounce para validação de formulário
+ * const validateField = debounce((value: string) => {
+ *   if (value.length < 3) {
+ *     setError('Mínimo 3 caracteres');
+ *   } else {
+ *     setError('');
+ *   }
+ * }, 500);
+ * ```
+ */
+declare const debounce: <T extends unknown[], R>(fn: (...args: T) => R, delay: number) => (...args: T) => void;
+
+export { debounce, defer, eager };

package/dist/utils/execution.js

@@ -0,0 +1,3 @@
+var n=t=>t(),u=t=>new Promise((r,e)=>{setTimeout(()=>{try{r(t());}catch(o){e(o);}},0);}),T=(t,r)=>{let e=null;return (...o)=>{e&&clearTimeout(e),e=setTimeout(()=>{t(...o),e=null;},r);}};
+
+export { T as debounce, u as defer, n as eager };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zydon/common",
-  "version": "2.5.42",
+  "version": "2.5.43",
   "license": "MIT",
   "type": "module",
   "module": "./dist/index.js",

package/dist/utils/eager.d.ts

@@ -1,36 +0,0 @@
-/**
- * Executa imediatamente uma função e retorna seu resultado.
- *
- * Esta função utilitária é usada para avaliar expressões de forma "eager" (ansiosa),
- * executando a função fornecida imediatamente e retornando seu valor. É útil em
- * situações onde você quer forçar a execução imediata de uma função que poderia
- * ser avaliada de forma lazy (preguiçosa).
- *
- * @template T - O tipo do valor retornado pela função
- * @param fn - A função a ser executada imediatamente
- * @returns O resultado da execução da função
- *
- * @example
- * ```typescript
- * // Execução imediata de uma computação
- * const result = eager(() => {
- *   console.log('Executando agora!');
- *   return 42;
- * }); // result = 42, e o console.log é executado imediatamente
- *
- * // Útil para inicialização de valores
- * const config = eager(() => ({
- *   apiUrl: process.env.API_URL || 'http://localhost:3000',
- *   timeout: 5000
- * }));
- *
- * // Forçar execução de side effects
- * eager(() => {
- *   localStorage.setItem('initialized', 'true');
- *   return null;
- * });
- * ```
- */
-declare const eager: <T>(fn: () => T) => T;
-
-export { eager };

package/dist/utils/eager.js

@@ -1,3 +0,0 @@
-var o=e=>e();
-
-export { o as eager };