@umodeapporg/ui 0.0.0-canary.ca10e69

package/dist/helpers/urlParamSync.js

@@ -0,0 +1,54 @@
+const TABS_URL_PARAM = "activeTab";
+const URL_PARAM_PRIORITY = {
+  viewToggle: 1,
+  tabs: 2
+};
+const urlParamOwners = /* @__PURE__ */ new Map();
+const claimUrlParam = (key, ownerId, priority) => {
+  const currentOwner = urlParamOwners.get(key);
+  if (!currentOwner || currentOwner.ownerId === ownerId || currentOwner.priority < priority) {
+    urlParamOwners.set(key, { ownerId, priority });
+    return true;
+  }
+  return false;
+};
+const releaseUrlParam = (key, ownerId) => {
+  if (urlParamOwners.get(key)?.ownerId !== ownerId) return;
+  urlParamOwners.delete(key);
+};
+const ownsUrlParam = (key, ownerId) => urlParamOwners.get(key)?.ownerId === ownerId;
+const queuedUpdates = /* @__PURE__ */ new Map();
+let queuedSetter = null;
+const flushQueuedUpdates = () => {
+  const updates = new Map(queuedUpdates);
+  const setSearchParams = queuedSetter;
+  queuedUpdates.clear();
+  queuedSetter = null;
+  if (!setSearchParams || !updates.size) return;
+  setSearchParams(
+    (previousParams) => {
+      const nextParams = new URLSearchParams(previousParams);
+      updates.forEach((value, key) => {
+        if (value) nextParams.set(key, value);
+        else nextParams.delete(key);
+      });
+      return nextParams;
+    },
+    { replace: true }
+  );
+};
+const queueUrlParamUpdate = (key, value, setSearchParams) => {
+  const isFirstOfTick = queuedUpdates.size === 0;
+  queuedUpdates.set(key, value);
+  queuedSetter = setSearchParams;
+  if (isFirstOfTick) queueMicrotask(flushQueuedUpdates);
+};
+export {
+  TABS_URL_PARAM,
+  URL_PARAM_PRIORITY,
+  claimUrlParam,
+  ownsUrlParam,
+  queueUrlParamUpdate,
+  releaseUrlParam
+};
+//# sourceMappingURL=urlParamSync.js.map

package/dist/helpers/urlParamSync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"urlParamSync.js","sources":["../../src/helpers/urlParamSync.ts"],"sourcesContent":["export type TUrlParamSetter = (\n  updater: (previousParams: URLSearchParams) => URLSearchParams,\n  options?: { replace?: boolean },\n) => void;\n\n/** Reservado ao `ControlledTabs`: nenhum outro controle pode assumir esse parâmetro. */\nexport const TABS_URL_PARAM = 'activeTab';\n\n/**\n * Quem manda no parâmetro quando dois controles pedem a mesma chave. Abas são navegação e ficam\n * acima de um seletor de visualização, então assumem a chave mesmo montando depois.\n */\nexport const URL_PARAM_PRIORITY = {\n  viewToggle: 1,\n  tabs: 2,\n} as const;\n\nexport type TUrlParamPriority = (typeof URL_PARAM_PRIORITY)[keyof typeof URL_PARAM_PRIORITY];\n\ninterface IUrlParamOwner {\n  ownerId: object;\n  priority: TUrlParamPriority;\n}\n\nconst urlParamOwners = new Map<string, IUrlParamOwner>();\n\nexport const claimUrlParam = (key: string, ownerId: object, priority: TUrlParamPriority): boolean => {\n  const currentOwner = urlParamOwners.get(key);\n\n  if (!currentOwner || currentOwner.ownerId === ownerId || currentOwner.priority < priority) {\n    urlParamOwners.set(key, { ownerId, priority });\n    return true;\n  }\n\n  return false;\n};\n\nexport const releaseUrlParam = (key: string, ownerId: object): void => {\n  if (urlParamOwners.get(key)?.ownerId !== ownerId) return;\n  urlParamOwners.delete(key);\n};\n\nexport const ownsUrlParam = (key: string, ownerId: object): boolean => urlParamOwners.get(key)?.ownerId === ownerId;\n\n// Escritas do mesmo tick são agrupadas numa navegação só. Sem isso, dois controles que gravam na\n// montagem (as abas e um toggle, por exemplo) chamariam `setSearchParams` em sequência, e o segundo\n// calcularia a partir da URL antiga porque o location ainda não mudou, apagando o parâmetro do primeiro.\nconst queuedUpdates = new Map<string, string>();\nlet queuedSetter: TUrlParamSetter | null = null;\n\nconst flushQueuedUpdates = (): void => {\n  const updates = new Map(queuedUpdates);\n  const setSearchParams = queuedSetter;\n\n  queuedUpdates.clear();\n  queuedSetter = null;\n\n  if (!setSearchParams || !updates.size) return;\n\n  setSearchParams(\n    (previousParams) => {\n      const nextParams = new URLSearchParams(previousParams);\n      updates.forEach((value, key) => {\n        if (value) nextParams.set(key, value);\n        else nextParams.delete(key);\n      });\n      return nextParams;\n    },\n    { replace: true },\n  );\n};\n\n/** Agenda a gravação de um parâmetro, preservando os demais. Valor vazio remove o parâmetro. */\nexport const queueUrlParamUpdate = (key: string, value: string, setSearchParams: TUrlParamSetter): void => {\n  const isFirstOfTick = queuedUpdates.size === 0;\n\n  queuedUpdates.set(key, value);\n  queuedSetter = setSearchParams;\n\n  if (isFirstOfTick) queueMicrotask(flushQueuedUpdates);\n};\n"],"names":[],"mappings":"AAMO,MAAM,iBAAiB;AAMvB,MAAM,qBAAqB;AAAA,EAChC,YAAY;AAAA,EACZ,MAAM;AACR;AASA,MAAM,qCAAqB,IAAA;AAEpB,MAAM,gBAAgB,CAAC,KAAa,SAAiB,aAAyC;AACnG,QAAM,eAAe,eAAe,IAAI,GAAG;AAE3C,MAAI,CAAC,gBAAgB,aAAa,YAAY,WAAW,aAAa,WAAW,UAAU;AACzF,mBAAe,IAAI,KAAK,EAAE,SAAS,UAAU;AAC7C,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEO,MAAM,kBAAkB,CAAC,KAAa,YAA0B;AACrE,MAAI,eAAe,IAAI,GAAG,GAAG,YAAY,QAAS;AAClD,iBAAe,OAAO,GAAG;AAC3B;AAEO,MAAM,eAAe,CAAC,KAAa,YAA6B,eAAe,IAAI,GAAG,GAAG,YAAY;AAK5G,MAAM,oCAAoB,IAAA;AAC1B,IAAI,eAAuC;AAE3C,MAAM,qBAAqB,MAAY;AACrC,QAAM,UAAU,IAAI,IAAI,aAAa;AACrC,QAAM,kBAAkB;AAExB,gBAAc,MAAA;AACd,iBAAe;AAEf,MAAI,CAAC,mBAAmB,CAAC,QAAQ,KAAM;AAEvC;AAAA,IACE,CAAC,mBAAmB;AAClB,YAAM,aAAa,IAAI,gBAAgB,cAAc;AACrD,cAAQ,QAAQ,CAAC,OAAO,QAAQ;AAC9B,YAAI,MAAO,YAAW,IAAI,KAAK,KAAK;AAAA,YAC/B,YAAW,OAAO,GAAG;AAAA,MAC5B,CAAC;AACD,aAAO;AAAA,IACT;AAAA,IACA,EAAE,SAAS,KAAA;AAAA,EAAK;AAEpB;AAGO,MAAM,sBAAsB,CAAC,KAAa,OAAe,oBAA2C;AACzG,QAAM,gBAAgB,cAAc,SAAS;AAE7C,gBAAc,IAAI,KAAK,KAAK;AAC5B,iBAAe;AAEf,MAAI,8BAA8B,kBAAkB;AACtD;"}

package/dist/helpers/utilityHelpers.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Check if a string is valid JSON
+ * @param str - The string to validate
+ * @returns True if string is valid JSON, false otherwise
+ */
+export declare const isJSON: (str: string) => boolean;
+/**
+ * Generate label for action button based on load more state
+ * @param canLoadMore - Whether more items can be loaded
+ * @param remainingItems - Number of remaining items to load
+ * @returns Button label in Portuguese: 'Ver Mais (N)' or 'Ver Menos'
+ */
+export declare const getActionButtonLabel: (canLoadMore: boolean, remainingItems: number) => string;
+/**
+ * Generate a unique, time-ordered Snowflake ID as a decimal string (safe in JSON).
+ * @returns A Snowflake ID string
+ */
+export declare const generateUUID: () => string;
+/**
+ * Check if an object is empty (has no properties)
+ * @param obj - The object to check
+ * @returns True if object is empty, false otherwise
+ */
+export declare const isEmptyObject: (obj: unknown) => boolean;
+/**
+ * Convert rem to px using the live root font-size, so px-only APIs (drawer size props,
+ * canvas math) follow the fluid density scale (html font-size clamp).
+ * @param rem - Value in rem units
+ * @returns Equivalent pixels at the current root font-size
+ */
+export declare const remToPx: (rem: number) => number;
+/**
+ * Create a delay/sleep function using Promise
+ * @param ms - Number of milliseconds to wait
+ * @returns Promise that resolves after the specified time
+ */
+export declare const sleep: (ms: number) => Promise<unknown>;
+/**
+ * Map over items running at most `limit` async tasks concurrently.
+ * Never rejects: every item resolves to a PromiseSettledResult so callers can build error summaries.
+ * @param items - The items to process
+ * @param limit - Maximum number of concurrent tasks
+ * @param task - Async function applied to each item
+ * @returns Settled results in the original item order
+ */
+export declare const mapWithConcurrency: <T, R>(items: ReadonlyArray<T>, limit: number, task: (item: T, index: number) => Promise<R>) => Promise<Array<PromiseSettledResult<R>>>;
+/**
+ * Download a file from a Blob object
+ * @param blob - The blob data to download
+ * @param filename - The name of the file to download
+ */
+export declare const downloadFromBlob: (blob: Blob, filename: string) => void;
+/**
+ * Handle the complete download process with loading state management
+ * @param fetchFunction - Function that returns a Promise<Blob> to fetch the data
+ * @param filename - Name of the file to download
+ * @param setLoading - Optional function to set the loading state
+ * @returns Promise that resolves when the download is complete
+ */
+export declare const handleDownload: (fetchFunction: () => Promise<Blob>, filename: string, setLoading?: (isLoading: boolean) => void) => Promise<void>;
+/**
+ * Clear all URL parameters from the current location
+ * @returns void
+ */
+export declare const clearUrlParams: () => void;
+export declare function formatSizesToArray(data: Array<{
+    size: string;
+    quantity: number;
+}>): Array<{
+    [size: string]: number;
+}>;
+/**
+ * Runs an async mapper over a list with at most `limit` calls in flight, keeping the
+ * result aligned with the input order (same shape as `Promise.allSettled`).
+ *
+ * `Promise.allSettled(items.map(fetch))` opens EVERY request at once. With a page of
+ * records that is already dozens of sockets, and a surface that renders several pages
+ * side by side (a kanban board) it multiplies until the browser stalls and the token
+ * expires mid-burst, turning the tail of the burst into 401s and refresh storms.
+ */
+export declare const settleWithConcurrency: <TItem, TResult>(items: Array<TItem>, limit: number, mapper: (item: TItem, index: number) => Promise<TResult>) => Promise<Array<PromiseSettledResult<TResult>>>;

package/dist/helpers/utilityHelpers.js

@@ -0,0 +1,133 @@
+import { uiLogger } from "./uiLogger.js";
+const isJSON = (str) => {
+  try {
+    JSON.parse(str);
+  } catch (e) {
+    return false;
+  }
+  return true;
+};
+const getActionButtonLabel = (canLoadMore, remainingItems) => {
+  return canLoadMore ? `Ver Mais (${remainingItems})` : "Ver Menos";
+};
+const EPOCH_MS = 1288834974657n;
+const SEQUENCE_MASK = 0xfffn;
+const NODE_SHIFT = 12n;
+const TIME_SHIFT = 22n;
+let lastTimestamp = -1n;
+let sequence = 0n;
+const nodeId = BigInt(Math.floor(Math.random() * 1024));
+const waitNextMillis = (after) => {
+  let t = BigInt(Date.now()) - EPOCH_MS;
+  while (t <= after) {
+    t = BigInt(Date.now()) - EPOCH_MS;
+  }
+  return t;
+};
+const generateUUID = () => {
+  let timestamp = BigInt(Date.now()) - EPOCH_MS;
+  if (timestamp < lastTimestamp) {
+    timestamp = waitNextMillis(lastTimestamp);
+  }
+  if (timestamp === lastTimestamp) {
+    sequence = sequence + 1n & SEQUENCE_MASK;
+    if (sequence === 0n) {
+      timestamp = waitNextMillis(lastTimestamp);
+    }
+  } else {
+    sequence = 0n;
+  }
+  lastTimestamp = timestamp;
+  const id = timestamp << TIME_SHIFT | nodeId << NODE_SHIFT | sequence;
+  return id.toString();
+};
+const isEmptyObject = (obj) => typeof obj === "object" && obj !== null && Object.keys(obj).length === 0;
+const remToPx = (rem) => {
+  const rootFontSize = Number.parseFloat(getComputedStyle(document.documentElement).fontSize) || 16;
+  return Math.round(rem * rootFontSize);
+};
+const sleep = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+const mapWithConcurrency = async (items, limit, task) => {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const worker = async () => {
+    while (cursor < items.length) {
+      const index = cursor;
+      cursor += 1;
+      try {
+        results[index] = { status: "fulfilled", value: await task(items[index], index) };
+      } catch (reason) {
+        results[index] = { status: "rejected", reason };
+      }
+    }
+  };
+  const workerCount = Math.max(1, Math.min(limit, items.length));
+  await Promise.all(Array.from({ length: workerCount }, worker));
+  return results;
+};
+const downloadFromBlob = (blob, filename) => {
+  if (!blob) return;
+  const url = window.URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  a.remove();
+};
+const handleDownload = async (fetchFunction, filename, setLoading) => {
+  try {
+    setLoading?.(true);
+    const blob = await fetchFunction();
+    downloadFromBlob(blob, filename);
+  } catch (error) {
+    uiLogger.error(error);
+  } finally {
+    setLoading?.(false);
+  }
+};
+const clearUrlParams = () => {
+  const url = window.location.protocol + "//" + window.location.host + window.location.pathname;
+  window.history.pushState({ path: url }, "", url);
+};
+function formatSizesToArray(data) {
+  return data.map((item) => ({
+    [item.size]: item.quantity
+  }));
+}
+const settleWithConcurrency = async (items, limit, mapper) => {
+  const safeItems = items ?? [];
+  const results = new Array(safeItems.length);
+  const maxInFlight = Math.max(1, limit);
+  let nextIndex = 0;
+  const runWorker = async () => {
+    while (nextIndex < safeItems.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      try {
+        results[index] = { status: "fulfilled", value: await mapper(safeItems[index], index) };
+      } catch (reason) {
+        results[index] = { status: "rejected", reason };
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(maxInFlight, safeItems.length) }, runWorker));
+  return results;
+};
+export {
+  clearUrlParams,
+  downloadFromBlob,
+  formatSizesToArray,
+  generateUUID,
+  getActionButtonLabel,
+  handleDownload,
+  isEmptyObject,
+  isJSON,
+  mapWithConcurrency,
+  remToPx,
+  settleWithConcurrency,
+  sleep
+};
+//# sourceMappingURL=utilityHelpers.js.map

package/dist/helpers/utilityHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilityHelpers.js","sources":["../../src/helpers/utilityHelpers.ts"],"sourcesContent":["import { uiLogger } from './uiLogger';\n\n/**\n * Check if a string is valid JSON\n * @param str - The string to validate\n * @returns True if string is valid JSON, false otherwise\n */\nexport const isJSON = (str: string): boolean => {\n  try {\n    JSON.parse(str);\n  } catch (e) {\n    return false;\n  }\n  return true;\n};\n\n/**\n * Generate label for action button based on load more state\n * @param canLoadMore - Whether more items can be loaded\n * @param remainingItems - Number of remaining items to load\n * @returns Button label in Portuguese: 'Ver Mais (N)' or 'Ver Menos'\n */\nexport const getActionButtonLabel = (canLoadMore: boolean, remainingItems: number) => {\n  return canLoadMore ? `Ver Mais (${remainingItems})` : 'Ver Menos';\n};\n\n/** Epoch Twitter Snowflake (ms). IDs como string decimal (seguro em JSON). */\nconst EPOCH_MS = 1288834974657n;\nconst SEQUENCE_MASK = 0xfffn;\nconst NODE_SHIFT = 12n;\nconst TIME_SHIFT = 22n;\n\nlet lastTimestamp = -1n;\nlet sequence = 0n;\nconst nodeId = BigInt(Math.floor(Math.random() * 1024));\n\nconst waitNextMillis = (after: bigint): bigint => {\n  let t = BigInt(Date.now()) - EPOCH_MS;\n  while (t <= after) {\n    t = BigInt(Date.now()) - EPOCH_MS;\n  }\n  return t;\n};\n\n/**\n * Generate a unique, time-ordered Snowflake ID as a decimal string (safe in JSON).\n * @returns A Snowflake ID string\n */\nexport const generateUUID = (): string => {\n  let timestamp = BigInt(Date.now()) - EPOCH_MS;\n\n  if (timestamp < lastTimestamp) {\n    timestamp = waitNextMillis(lastTimestamp);\n  }\n\n  if (timestamp === lastTimestamp) {\n    sequence = (sequence + 1n) & SEQUENCE_MASK;\n    if (sequence === 0n) {\n      timestamp = waitNextMillis(lastTimestamp);\n    }\n  } else {\n    sequence = 0n;\n  }\n\n  lastTimestamp = timestamp;\n  const id = (timestamp << TIME_SHIFT) | (nodeId << NODE_SHIFT) | sequence;\n  return id.toString();\n};\n\n/**\n * Check if an object is empty (has no properties)\n * @param obj - The object to check\n * @returns True if object is empty, false otherwise\n */\nexport const isEmptyObject = (obj: unknown) => typeof obj === 'object' && obj !== null && Object.keys(obj).length === 0;\n\n/**\n * Convert rem to px using the live root font-size, so px-only APIs (drawer size props,\n * canvas math) follow the fluid density scale (html font-size clamp).\n * @param rem - Value in rem units\n * @returns Equivalent pixels at the current root font-size\n */\nexport const remToPx = (rem: number): number => {\n  const rootFontSize = Number.parseFloat(getComputedStyle(document.documentElement).fontSize) || 16;\n  return Math.round(rem * rootFontSize);\n};\n\n/**\n * Create a delay/sleep function using Promise\n * @param ms - Number of milliseconds to wait\n * @returns Promise that resolves after the specified time\n */\nexport const sleep = (ms: number) => {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n};\n\n/**\n * Map over items running at most `limit` async tasks concurrently.\n * Never rejects: every item resolves to a PromiseSettledResult so callers can build error summaries.\n * @param items - The items to process\n * @param limit - Maximum number of concurrent tasks\n * @param task - Async function applied to each item\n * @returns Settled results in the original item order\n */\nexport const mapWithConcurrency = async <T, R>(\n  items: ReadonlyArray<T>,\n  limit: number,\n  task: (item: T, index: number) => Promise<R>,\n): Promise<Array<PromiseSettledResult<R>>> => {\n  const results: Array<PromiseSettledResult<R>> = new Array(items.length);\n  let cursor = 0;\n\n  const worker = async (): Promise<void> => {\n    while (cursor < items.length) {\n      const index = cursor;\n      cursor += 1;\n      try {\n        results[index] = { status: 'fulfilled', value: await task(items[index], index) };\n      } catch (reason) {\n        results[index] = { status: 'rejected', reason };\n      }\n    }\n  };\n\n  const workerCount = Math.max(1, Math.min(limit, items.length));\n  await Promise.all(Array.from({ length: workerCount }, worker));\n\n  return results;\n};\n\n/**\n * Download a file from a Blob object\n * @param blob - The blob data to download\n * @param filename - The name of the file to download\n */\nexport const downloadFromBlob = (blob: Blob, filename: string): void => {\n  if (!blob) return;\n\n  const url = window.URL.createObjectURL(blob);\n  const a = document.createElement('a');\n  a.href = url;\n  a.download = filename;\n  document.body.appendChild(a);\n  a.click();\n  a.remove();\n};\n\n/**\n * Handle the complete download process with loading state management\n * @param fetchFunction - Function that returns a Promise<Blob> to fetch the data\n * @param filename - Name of the file to download\n * @param setLoading - Optional function to set the loading state\n * @returns Promise that resolves when the download is complete\n */\nexport const handleDownload = async (\n  fetchFunction: () => Promise<Blob>,\n  filename: string,\n  setLoading?: (isLoading: boolean) => void,\n): Promise<void> => {\n  try {\n    setLoading?.(true);\n    const blob = await fetchFunction();\n    downloadFromBlob(blob, filename);\n  } catch (error) {\n    uiLogger.error(error);\n  } finally {\n    setLoading?.(false);\n  }\n};\n\n/**\n * Clear all URL parameters from the current location\n * @returns void\n */\nexport const clearUrlParams = (): void => {\n  const url = window.location.protocol + '//' + window.location.host + window.location.pathname;\n  window.history.pushState({ path: url }, '', url);\n};\n\nexport function formatSizesToArray(data: Array<{ size: string; quantity: number }>): Array<{ [size: string]: number }> {\n  return data.map((item) => ({\n    [item.size]: item.quantity,\n  }));\n}\n\n/**\n * Runs an async mapper over a list with at most `limit` calls in flight, keeping the\n * result aligned with the input order (same shape as `Promise.allSettled`).\n *\n * `Promise.allSettled(items.map(fetch))` opens EVERY request at once. With a page of\n * records that is already dozens of sockets, and a surface that renders several pages\n * side by side (a kanban board) it multiplies until the browser stalls and the token\n * expires mid-burst, turning the tail of the burst into 401s and refresh storms.\n */\nexport const settleWithConcurrency = async <TItem, TResult>(\n  items: Array<TItem>,\n  limit: number,\n  mapper: (item: TItem, index: number) => Promise<TResult>,\n): Promise<Array<PromiseSettledResult<TResult>>> => {\n  const safeItems = items ?? [];\n  const results = new Array<PromiseSettledResult<TResult>>(safeItems.length);\n  const maxInFlight = Math.max(1, limit);\n  let nextIndex = 0;\n\n  const runWorker = async (): Promise<void> => {\n    while (nextIndex < safeItems.length) {\n      const index = nextIndex;\n      nextIndex += 1;\n\n      try {\n        results[index] = { status: 'fulfilled', value: await mapper(safeItems[index], index) };\n      } catch (reason) {\n        results[index] = { status: 'rejected', reason };\n      }\n    }\n  };\n\n  await Promise.all(Array.from({ length: Math.min(maxInFlight, safeItems.length) }, runWorker));\n\n  return results;\n};\n"],"names":[],"mappings":"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"}

package/dist/helpers/validationHelpers.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Validate if a string is a valid email format
+ * @param email - The email string to validate
+ * @returns True if email format is valid, false otherwise
+ */
+export declare const validateEmail: (email: string) => boolean;
+/**
+ * Validate if a string is an absolute http(s) URL
+ * @param url - The URL string to validate
+ * @returns True if the URL is absolute and uses http or https, false otherwise
+ */
+export declare const validateHttpUrl: (url: string) => boolean;
+export declare const PASSWORD_MIN_LENGTH = 8;
+export declare const PASSWORD_NUMBER_REGEX: RegExp;
+export declare const PASSWORD_SPECIAL_CHAR_REGEX: RegExp;
+export declare const PASSWORD_UPPERCASE_REGEX: RegExp;
+export declare const PASSWORD_LOWERCASE_REGEX: RegExp;
+/**
+ * Validate if a password meets security requirements
+ * Requires: min 8 chars, uppercase, lowercase, number, special character
+ * @param password - The password string to validate
+ * @returns True if password meets all requirements, false otherwise
+ */
+export declare const validatePassword: (password: string) => boolean;
+/**
+ * Check if password is being typed and has invalid requirements
+ * Used to show visual feedback when user is typing but password is still invalid
+ * @param password - The password string to check
+ * @returns True if password has content but doesn't meet all requirements, false otherwise
+ */
+export declare const hasPasswordError: (password: string) => boolean;
+/**
+ * HTML tooltip description for password requirements
+ * Displays the password validation rules in Portuguese
+ */
+export declare const tooltipDescription = "\n  A senha deve ter: <br />\n  - Pelo menos 8 caracteres <br />\n  - Pelo menos uma letra mai\u00FAscula <br />\n  - Pelo menos uma letra min\u00FAscula <br />\n  - Pelo menos um n\u00FAmero <br />\n  - Pelo menos um caractere especial (ex: !, @, #, $, ;) <br />\n";

package/dist/helpers/validationHelpers.js

@@ -0,0 +1,44 @@
+const validateEmail = (email) => {
+  const regex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return regex.test(email);
+};
+const validateHttpUrl = (url) => {
+  try {
+    const parsed = new URL(String(url ?? "").trim());
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+};
+const PASSWORD_MIN_LENGTH = 8;
+const PASSWORD_NUMBER_REGEX = /\d/;
+const PASSWORD_SPECIAL_CHAR_REGEX = /[^A-Za-z0-9\s]/;
+const PASSWORD_UPPERCASE_REGEX = /[A-Z]/;
+const PASSWORD_LOWERCASE_REGEX = /[a-z]/;
+const validatePassword = (password) => {
+  return password.length >= PASSWORD_MIN_LENGTH && PASSWORD_NUMBER_REGEX.test(password) && PASSWORD_SPECIAL_CHAR_REGEX.test(password) && PASSWORD_UPPERCASE_REGEX.test(password) && PASSWORD_LOWERCASE_REGEX.test(password);
+};
+const hasPasswordError = (password) => {
+  return password.length > 0 && !validatePassword(password);
+};
+const tooltipDescription = `
+  A senha deve ter: <br />
+  - Pelo menos ${PASSWORD_MIN_LENGTH} caracteres <br />
+  - Pelo menos uma letra maiúscula <br />
+  - Pelo menos uma letra minúscula <br />
+  - Pelo menos um número <br />
+  - Pelo menos um caractere especial (ex: !, @, #, $, ;) <br />
+`;
+export {
+  PASSWORD_LOWERCASE_REGEX,
+  PASSWORD_MIN_LENGTH,
+  PASSWORD_NUMBER_REGEX,
+  PASSWORD_SPECIAL_CHAR_REGEX,
+  PASSWORD_UPPERCASE_REGEX,
+  hasPasswordError,
+  tooltipDescription,
+  validateEmail,
+  validateHttpUrl,
+  validatePassword
+};
+//# sourceMappingURL=validationHelpers.js.map

package/dist/helpers/validationHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validationHelpers.js","sources":["../../src/helpers/validationHelpers.ts"],"sourcesContent":["/**\n * Validate if a string is a valid email format\n * @param email - The email string to validate\n * @returns True if email format is valid, false otherwise\n */\nexport const validateEmail = (email: string) => {\n  const regex = /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/;\n  return regex.test(email);\n};\n\n/**\n * Validate if a string is an absolute http(s) URL\n * @param url - The URL string to validate\n * @returns True if the URL is absolute and uses http or https, false otherwise\n */\nexport const validateHttpUrl = (url: string) => {\n  try {\n    const parsed = new URL(String(url ?? '').trim());\n\n    return parsed.protocol === 'http:' || parsed.protocol === 'https:';\n  } catch {\n    return false;\n  }\n};\n\nexport const PASSWORD_MIN_LENGTH = 8;\nexport const PASSWORD_NUMBER_REGEX = /\\d/;\nexport const PASSWORD_SPECIAL_CHAR_REGEX = /[^A-Za-z0-9\\s]/;\nexport const PASSWORD_UPPERCASE_REGEX = /[A-Z]/;\nexport const PASSWORD_LOWERCASE_REGEX = /[a-z]/;\n\n/**\n * Validate if a password meets security requirements\n * Requires: min 8 chars, uppercase, lowercase, number, special character\n * @param password - The password string to validate\n * @returns True if password meets all requirements, false otherwise\n */\nexport const validatePassword = (password: string) => {\n  return (\n    password.length >= PASSWORD_MIN_LENGTH &&\n    PASSWORD_NUMBER_REGEX.test(password) &&\n    PASSWORD_SPECIAL_CHAR_REGEX.test(password) &&\n    PASSWORD_UPPERCASE_REGEX.test(password) &&\n    PASSWORD_LOWERCASE_REGEX.test(password)\n  );\n};\n\n/**\n * Check if password is being typed and has invalid requirements\n * Used to show visual feedback when user is typing but password is still invalid\n * @param password - The password string to check\n * @returns True if password has content but doesn't meet all requirements, false otherwise\n */\nexport const hasPasswordError = (password: string) => {\n  return password.length > 0 && !validatePassword(password);\n};\n\n/**\n * HTML tooltip description for password requirements\n * Displays the password validation rules in Portuguese\n */\n// eslint-disable-next-line i18n-check/no-portuguese-strings\nexport const tooltipDescription = `\n  A senha deve ter: <br />\n  - Pelo menos ${PASSWORD_MIN_LENGTH} caracteres <br />\n  - Pelo menos uma letra maiúscula <br />\n  - Pelo menos uma letra minúscula <br />\n  - Pelo menos um número <br />\n  - Pelo menos um caractere especial (ex: !, @, #, $, ;) <br />\n`;\n"],"names":[],"mappings":"AAKO,MAAM,gBAAgB,CAAC,UAAkB;AAC9C,QAAM,QAAQ;AACd,SAAO,MAAM,KAAK,KAAK;AACzB;AAOO,MAAM,kBAAkB,CAAC,QAAgB;AAC9C,MAAI;AACF,UAAM,SAAS,IAAI,IAAI,OAAO,OAAO,EAAE,EAAE,MAAM;AAE/C,WAAO,OAAO,aAAa,WAAW,OAAO,aAAa;AAAA,EAC5D,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEO,MAAM,sBAAsB;AAC5B,MAAM,wBAAwB;AAC9B,MAAM,8BAA8B;AACpC,MAAM,2BAA2B;AACjC,MAAM,2BAA2B;AAQjC,MAAM,mBAAmB,CAAC,aAAqB;AACpD,SACE,SAAS,UAAU,uBACnB,sBAAsB,KAAK,QAAQ,KACnC,4BAA4B,KAAK,QAAQ,KACzC,yBAAyB,KAAK,QAAQ,KACtC,yBAAyB,KAAK,QAAQ;AAE1C;AAQO,MAAM,mBAAmB,CAAC,aAAqB;AACpD,SAAO,SAAS,SAAS,KAAK,CAAC,iBAAiB,QAAQ;AAC1D;AAOO,MAAM,qBAAqB;AAAA;AAAA,iBAEjB,mBAAmB;AAAA;AAAA;AAAA;AAAA;AAAA;"}

package/dist/hooks/useAnchoredFloating.d.ts

@@ -0,0 +1,22 @@
+export type TFloatingPlacement = 'top' | 'top-start' | 'top-end' | 'right' | 'right-start' | 'right-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end';
+interface IUseAnchoredFloatingOptions {
+    open: boolean;
+    placement?: TFloatingPlacement;
+    offsetPx?: number;
+    /** Sizes the floating element to the reference width (select-style dropdowns). */
+    matchReferenceWidth?: boolean;
+    /** Caps the floating element to the space left in the viewport. */
+    constrainToViewport?: boolean;
+}
+/**
+ * Positions a floating element against a reference. `autoUpdate` re-runs on scroll of every
+ * ancestor, on resize and on layout shifts, which is what keeps a menu attached to a row
+ * inside a scrolling table.
+ */
+export declare const useAnchoredFloating: ({ open, placement, offsetPx, matchReferenceWidth, constrainToViewport, }: IUseAnchoredFloatingOptions) => {
+    setReference: (node: HTMLElement | null) => void;
+    setFloating: (node: HTMLElement | null) => void;
+    referenceRef: import('react').MutableRefObject<HTMLElement | null>;
+    floatingRef: import('react').MutableRefObject<HTMLElement | null>;
+};
+export {};

package/dist/hooks/useAnchoredFloating.js

@@ -0,0 +1,59 @@
+import { useRef, useCallback, useEffect } from "react";
+import { uiLogger } from "../helpers/uiLogger.js";
+import { autoUpdate, offset, flip, shift, size, computePosition } from "@floating-ui/dom";
+const VIEWPORT_PADDING = 8;
+const useAnchoredFloating = ({
+  open,
+  placement = "bottom-start",
+  offsetPx = 6,
+  matchReferenceWidth = false,
+  constrainToViewport = true
+}) => {
+  const referenceRef = useRef(null);
+  const floatingRef = useRef(null);
+  const setReference = useCallback((node) => {
+    referenceRef.current = node;
+  }, []);
+  const setFloating = useCallback((node) => {
+    floatingRef.current = node;
+  }, []);
+  useEffect(() => {
+    const reference = referenceRef.current;
+    const floating = floatingRef.current;
+    if (!open || !reference || !floating) return void 0;
+    const updatePosition = async () => {
+      const middleware = [offset(offsetPx), flip({ padding: VIEWPORT_PADDING }), shift({ padding: VIEWPORT_PADDING })];
+      if (matchReferenceWidth || constrainToViewport) {
+        middleware.push(
+          size({
+            padding: VIEWPORT_PADDING,
+            apply({ rects, availableHeight, elements }) {
+              if (matchReferenceWidth) elements.floating.style.width = `${rects.reference.width}px`;
+              if (constrainToViewport) elements.floating.style.maxHeight = `${availableHeight}px`;
+            }
+          })
+        );
+      }
+      try {
+        const { x, y } = await computePosition(reference, floating, {
+          placement,
+          strategy: "fixed",
+          middleware
+        });
+        floating.style.position = "fixed";
+        floating.style.left = `${x}px`;
+        floating.style.top = `${y}px`;
+      } catch (error) {
+        uiLogger.error("useAnchoredFloating: failed to position floating element", error);
+      }
+    };
+    return autoUpdate(reference, floating, () => {
+      void updatePosition();
+    });
+  }, [open, placement, offsetPx, matchReferenceWidth, constrainToViewport]);
+  return { setReference, setFloating, referenceRef, floatingRef };
+};
+export {
+  useAnchoredFloating
+};
+//# sourceMappingURL=useAnchoredFloating.js.map

package/dist/hooks/useAnchoredFloating.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnchoredFloating.js","sources":["../../src/hooks/useAnchoredFloating.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from 'react';\n\nimport { uiLogger } from '@/helpers/uiLogger';\nimport { autoUpdate, computePosition, flip, offset, shift, size } from '@floating-ui/dom';\n\nexport type TFloatingPlacement =\n  | 'top'\n  | 'top-start'\n  | 'top-end'\n  | 'right'\n  | 'right-start'\n  | 'right-end'\n  | 'bottom'\n  | 'bottom-start'\n  | 'bottom-end'\n  | 'left'\n  | 'left-start'\n  | 'left-end';\n\nconst VIEWPORT_PADDING = 8;\n\ninterface IUseAnchoredFloatingOptions {\n  open: boolean;\n  placement?: TFloatingPlacement;\n  offsetPx?: number;\n  /** Sizes the floating element to the reference width (select-style dropdowns). */\n  matchReferenceWidth?: boolean;\n  /** Caps the floating element to the space left in the viewport. */\n  constrainToViewport?: boolean;\n}\n\n/**\n * Positions a floating element against a reference. `autoUpdate` re-runs on scroll of every\n * ancestor, on resize and on layout shifts, which is what keeps a menu attached to a row\n * inside a scrolling table.\n */\nexport const useAnchoredFloating = ({\n  open,\n  placement = 'bottom-start',\n  offsetPx = 6,\n  matchReferenceWidth = false,\n  constrainToViewport = true,\n}: IUseAnchoredFloatingOptions) => {\n  const referenceRef = useRef<HTMLElement | null>(null);\n  const floatingRef = useRef<HTMLElement | null>(null);\n\n  const setReference = useCallback((node: HTMLElement | null) => {\n    referenceRef.current = node;\n  }, []);\n\n  const setFloating = useCallback((node: HTMLElement | null) => {\n    floatingRef.current = node;\n  }, []);\n\n  useEffect(() => {\n    const reference = referenceRef.current;\n    const floating = floatingRef.current;\n    if (!open || !reference || !floating) return undefined;\n\n    const updatePosition = async () => {\n      const middleware = [offset(offsetPx), flip({ padding: VIEWPORT_PADDING }), shift({ padding: VIEWPORT_PADDING })];\n\n      if (matchReferenceWidth || constrainToViewport) {\n        middleware.push(\n          size({\n            padding: VIEWPORT_PADDING,\n            apply({ rects, availableHeight, elements }) {\n              if (matchReferenceWidth) elements.floating.style.width = `${rects.reference.width}px`;\n              if (constrainToViewport) elements.floating.style.maxHeight = `${availableHeight}px`;\n            },\n          }),\n        );\n      }\n\n      try {\n        const { x, y } = await computePosition(reference, floating, {\n          placement,\n          strategy: 'fixed',\n          middleware,\n        });\n\n        floating.style.position = 'fixed';\n        floating.style.left = `${x}px`;\n        floating.style.top = `${y}px`;\n      } catch (error) {\n        uiLogger.error('useAnchoredFloating: failed to position floating element', error);\n      }\n    };\n\n    return autoUpdate(reference, floating, () => {\n      void updatePosition();\n    });\n  }, [open, placement, offsetPx, matchReferenceWidth, constrainToViewport]);\n\n  return { setReference, setFloating, referenceRef, floatingRef };\n};\n"],"names":[],"mappings":";;;AAmBA,MAAM,mBAAmB;AAiBlB,MAAM,sBAAsB,CAAC;AAAA,EAClC;AAAA,EACA,YAAY;AAAA,EACZ,WAAW;AAAA,EACX,sBAAsB;AAAA,EACtB,sBAAsB;AACxB,MAAmC;AACjC,QAAM,eAAe,OAA2B,IAAI;AACpD,QAAM,cAAc,OAA2B,IAAI;AAEnD,QAAM,eAAe,YAAY,CAAC,SAA6B;AAC7D,iBAAa,UAAU;AAAA,EACzB,GAAG,CAAA,CAAE;AAEL,QAAM,cAAc,YAAY,CAAC,SAA6B;AAC5D,gBAAY,UAAU;AAAA,EACxB,GAAG,CAAA,CAAE;AAEL,YAAU,MAAM;AACd,UAAM,YAAY,aAAa;AAC/B,UAAM,WAAW,YAAY;AAC7B,QAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,SAAU,QAAO;AAE7C,UAAM,iBAAiB,YAAY;AACjC,YAAM,aAAa,CAAC,OAAO,QAAQ,GAAG,KAAK,EAAE,SAAS,iBAAA,CAAkB,GAAG,MAAM,EAAE,SAAS,iBAAA,CAAkB,CAAC;AAE/G,UAAI,uBAAuB,qBAAqB;AAC9C,mBAAW;AAAA,UACT,KAAK;AAAA,YACH,SAAS;AAAA,YACT,MAAM,EAAE,OAAO,iBAAiB,YAAY;AAC1C,kBAAI,8BAA8B,SAAS,MAAM,QAAQ,GAAG,MAAM,UAAU,KAAK;AACjF,kBAAI,oBAAqB,UAAS,SAAS,MAAM,YAAY,GAAG,eAAe;AAAA,YACjF;AAAA,UAAA,CACD;AAAA,QAAA;AAAA,MAEL;AAEA,UAAI;AACF,cAAM,EAAE,GAAG,EAAA,IAAM,MAAM,gBAAgB,WAAW,UAAU;AAAA,UAC1D;AAAA,UACA,UAAU;AAAA,UACV;AAAA,QAAA,CACD;AAED,iBAAS,MAAM,WAAW;AAC1B,iBAAS,MAAM,OAAO,GAAG,CAAC;AAC1B,iBAAS,MAAM,MAAM,GAAG,CAAC;AAAA,MAC3B,SAAS,OAAO;AACd,iBAAS,MAAM,4DAA4D,KAAK;AAAA,MAClF;AAAA,IACF;AAEA,WAAO,WAAW,WAAW,UAAU,MAAM;AAC3C,WAAK,eAAA;AAAA,IACP,CAAC;AAAA,EACH,GAAG,CAAC,MAAM,WAAW,UAAU,qBAAqB,mBAAmB,CAAC;AAExE,SAAO,EAAE,cAAc,aAAa,cAAc,YAAA;AACpD;"}

package/dist/hooks/useBreakpoint.d.ts

@@ -0,0 +1,16 @@
+export declare const BREAKPOINTS: {
+    readonly tablet: 640;
+    readonly laptop: 1024;
+    readonly desktop: 1368;
+};
+export type TBreakpoint = 'mobile' | 'tablet' | 'laptop' | 'desktop';
+export interface IBreakpointState {
+    width: number;
+    breakpoint: TBreakpoint;
+    isMobile: boolean;
+    isTabletDown: boolean;
+    isLaptopDown: boolean;
+    isLaptopUp: boolean;
+    isDesktopUp: boolean;
+}
+export declare const useBreakpoint: () => IBreakpointState;

package/dist/hooks/useBreakpoint.js

@@ -0,0 +1,47 @@
+import { useState, useEffect } from "react";
+const BREAKPOINTS = { tablet: 640, laptop: 1024, desktop: 1368 };
+const getWidth = () => {
+  try {
+    return window.innerWidth;
+  } catch {
+    return BREAKPOINTS.desktop;
+  }
+};
+const resolveBreakpoint = (width) => {
+  if (width >= BREAKPOINTS.desktop) return "desktop";
+  if (width >= BREAKPOINTS.laptop) return "laptop";
+  if (width >= BREAKPOINTS.tablet) return "tablet";
+  return "mobile";
+};
+const useBreakpoint = () => {
+  const [width, setWidth] = useState(getWidth);
+  useEffect(() => {
+    let frame = null;
+    const handleResize = () => {
+      if (frame !== null) return;
+      frame = window.requestAnimationFrame(() => {
+        frame = null;
+        setWidth(getWidth());
+      });
+    };
+    window.addEventListener("resize", handleResize);
+    return () => {
+      if (frame !== null) window.cancelAnimationFrame(frame);
+      window.removeEventListener("resize", handleResize);
+    };
+  }, []);
+  return {
+    width,
+    breakpoint: resolveBreakpoint(width),
+    isMobile: width < BREAKPOINTS.tablet,
+    isTabletDown: width < BREAKPOINTS.laptop,
+    isLaptopDown: width < BREAKPOINTS.desktop,
+    isLaptopUp: width >= BREAKPOINTS.laptop,
+    isDesktopUp: width >= BREAKPOINTS.desktop
+  };
+};
+export {
+  BREAKPOINTS,
+  useBreakpoint
+};
+//# sourceMappingURL=useBreakpoint.js.map

package/dist/hooks/useBreakpoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBreakpoint.js","sources":["../../src/hooks/useBreakpoint.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\nexport const BREAKPOINTS = { tablet: 640, laptop: 1024, desktop: 1368 } as const;\n\nexport type TBreakpoint = 'mobile' | 'tablet' | 'laptop' | 'desktop';\n\nconst getWidth = (): number => {\n  try {\n    return window.innerWidth;\n  } catch {\n    return BREAKPOINTS.desktop;\n  }\n};\n\nconst resolveBreakpoint = (width: number): TBreakpoint => {\n  if (width >= BREAKPOINTS.desktop) return 'desktop';\n  if (width >= BREAKPOINTS.laptop) return 'laptop';\n  if (width >= BREAKPOINTS.tablet) return 'tablet';\n  return 'mobile';\n};\n\nexport interface IBreakpointState {\n  width: number;\n  breakpoint: TBreakpoint;\n  isMobile: boolean;\n  isTabletDown: boolean;\n  isLaptopDown: boolean;\n  isLaptopUp: boolean;\n  isDesktopUp: boolean;\n}\n\nexport const useBreakpoint = (): IBreakpointState => {\n  const [width, setWidth] = useState(getWidth);\n\n  // Coalesced into one animation frame: a drag-resize fires `resize` dozens of\n  // times per second and every consumer of this hook re-renders on each one.\n  useEffect(() => {\n    let frame: number | null = null;\n\n    const handleResize = () => {\n      if (frame !== null) return;\n      frame = window.requestAnimationFrame(() => {\n        frame = null;\n        setWidth(getWidth());\n      });\n    };\n\n    window.addEventListener('resize', handleResize);\n    return () => {\n      if (frame !== null) window.cancelAnimationFrame(frame);\n      window.removeEventListener('resize', handleResize);\n    };\n  }, []);\n\n  return {\n    width,\n    breakpoint: resolveBreakpoint(width),\n    isMobile: width < BREAKPOINTS.tablet,\n    isTabletDown: width < BREAKPOINTS.laptop,\n    isLaptopDown: width < BREAKPOINTS.desktop,\n    isLaptopUp: width >= BREAKPOINTS.laptop,\n    isDesktopUp: width >= BREAKPOINTS.desktop,\n  };\n};\n"],"names":[],"mappings":";AAEO,MAAM,cAAc,EAAE,QAAQ,KAAK,QAAQ,MAAM,SAAS,KAAA;AAIjE,MAAM,WAAW,MAAc;AAC7B,MAAI;AACF,WAAO,OAAO;AAAA,EAChB,QAAQ;AACN,WAAO,YAAY;AAAA,EACrB;AACF;AAEA,MAAM,oBAAoB,CAAC,UAA+B;AACxD,MAAI,SAAS,YAAY,QAAS,QAAO;AACzC,MAAI,SAAS,YAAY,OAAQ,QAAO;AACxC,MAAI,SAAS,YAAY,OAAQ,QAAO;AACxC,SAAO;AACT;AAYO,MAAM,gBAAgB,MAAwB;AACnD,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAS,QAAQ;AAI3C,YAAU,MAAM;AACd,QAAI,QAAuB;AAE3B,UAAM,eAAe,MAAM;AACzB,UAAI,UAAU,KAAM;AACpB,cAAQ,OAAO,sBAAsB,MAAM;AACzC,gBAAQ;AACR,iBAAS,UAAU;AAAA,MACrB,CAAC;AAAA,IACH;AAEA,WAAO,iBAAiB,UAAU,YAAY;AAC9C,WAAO,MAAM;AACX,UAAI,UAAU,KAAM,QAAO,qBAAqB,KAAK;AACrD,aAAO,oBAAoB,UAAU,YAAY;AAAA,IACnD;AAAA,EACF,GAAG,CAAA,CAAE;AAEL,SAAO;AAAA,IACL;AAAA,IACA,YAAY,kBAAkB,KAAK;AAAA,IACnC,UAAU,QAAQ,YAAY;AAAA,IAC9B,cAAc,QAAQ,YAAY;AAAA,IAClC,cAAc,QAAQ,YAAY;AAAA,IAClC,YAAY,SAAS,YAAY;AAAA,IACjC,aAAa,SAAS,YAAY;AAAA,EAAA;AAEtC;"}

package/dist/hooks/useDebounce.d.ts

@@ -0,0 +1,8 @@
+interface IUseDebounceOptions {
+    delay: number;
+}
+export declare const useDebounce: <T extends (...args: Array<unknown>) => unknown>(callback: T, { delay }: IUseDebounceOptions) => {
+    debouncedCallback: (...args: Parameters<T>) => void;
+    cancel: () => void;
+};
+export {};

package/dist/hooks/useDebounce.js

@@ -0,0 +1,36 @@
+import { useRef, useCallback, useEffect } from "react";
+const useDebounce = (callback, { delay }) => {
+  const timeoutRef = useRef(null);
+  const debouncedCallback = useCallback(
+    (...args) => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+      timeoutRef.current = setTimeout(() => {
+        callback(...args);
+      }, delay);
+    },
+    [callback, delay]
+  );
+  const cancel = useCallback(() => {
+    if (timeoutRef.current) {
+      clearTimeout(timeoutRef.current);
+      timeoutRef.current = null;
+    }
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+      }
+    };
+  }, []);
+  return {
+    debouncedCallback,
+    cancel
+  };
+};
+export {
+  useDebounce
+};
+//# sourceMappingURL=useDebounce.js.map

package/dist/hooks/useDebounce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDebounce.js","sources":["../../src/hooks/useDebounce.ts"],"sourcesContent":["import { useCallback, useEffect, useRef } from 'react';\n\ninterface IUseDebounceOptions {\n  delay: number;\n}\n\nexport const useDebounce = <T extends (...args: Array<unknown>) => unknown>(\n  callback: T,\n  { delay }: IUseDebounceOptions,\n) => {\n  const timeoutRef = useRef<NodeJS.Timeout | null>(null);\n\n  const debouncedCallback = useCallback(\n    (...args: Parameters<T>) => {\n      if (timeoutRef.current) {\n        clearTimeout(timeoutRef.current);\n      }\n\n      timeoutRef.current = setTimeout(() => {\n        callback(...args);\n      }, delay);\n    },\n    [callback, delay],\n  );\n\n  const cancel = useCallback(() => {\n    if (timeoutRef.current) {\n      clearTimeout(timeoutRef.current);\n      timeoutRef.current = null;\n    }\n  }, []);\n\n  useEffect(() => {\n    return () => {\n      if (timeoutRef.current) {\n        clearTimeout(timeoutRef.current);\n      }\n    };\n  }, []);\n\n  return {\n    debouncedCallback,\n    cancel,\n  };\n};\n"],"names":[],"mappings":";AAMO,MAAM,cAAc,CACzB,UACA,EAAE,YACC;AACH,QAAM,aAAa,OAA8B,IAAI;AAErD,QAAM,oBAAoB;AAAA,IACxB,IAAI,SAAwB;AAC1B,UAAI,WAAW,SAAS;AACtB,qBAAa,WAAW,OAAO;AAAA,MACjC;AAEA,iBAAW,UAAU,WAAW,MAAM;AACpC,iBAAS,GAAG,IAAI;AAAA,MAClB,GAAG,KAAK;AAAA,IACV;AAAA,IACA,CAAC,UAAU,KAAK;AAAA,EAAA;AAGlB,QAAM,SAAS,YAAY,MAAM;AAC/B,QAAI,WAAW,SAAS;AACtB,mBAAa,WAAW,OAAO;AAC/B,iBAAW,UAAU;AAAA,IACvB;AAAA,EACF,GAAG,CAAA,CAAE;AAEL,YAAU,MAAM;AACd,WAAO,MAAM;AACX,UAAI,WAAW,SAAS;AACtB,qBAAa,WAAW,OAAO;AAAA,MACjC;AAAA,IACF;AAAA,EACF,GAAG,CAAA,CAAE;AAEL,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EAAA;AAEJ;"}

package/dist/hooks/useFileAttachments.d.ts

@@ -0,0 +1,43 @@
+import { IFileAttachment } from '../interfaces/IFileAttachment';
+export type TFileUploader = (file: File, options: {
+    signal?: AbortSignal;
+    onProgress?: (percentage: number) => void;
+}) => Promise<IFileAttachment>;
+export type TStagedAttachmentStatus = 'uploading' | 'done' | 'error';
+export interface IStagedAttachmentExtras {
+    durationMs?: number;
+    transcript?: string;
+}
+export interface IStagedAttachment {
+    stagingId: string;
+    file: File;
+    previewUrl: string | null;
+    progress: number;
+    status: TStagedAttachmentStatus;
+    uploaded: IFileAttachment | null;
+    extras: IStagedAttachmentExtras;
+}
+export interface IUseFileAttachmentsOptions {
+    /** Storage seam: a surface with its own bucket passes its uploader instead of the shared one. */
+    uploadFile?: TFileUploader;
+    maxFiles?: number;
+    maxFileSizeBytes?: number;
+    compressImages?: boolean;
+}
+export interface IUseFileAttachmentsResult {
+    stagedAttachments: Array<IStagedAttachment>;
+    addFiles: (files: Array<File>, extras?: IStagedAttachmentExtras) => Promise<void>;
+    removeAttachment: (stagingId: string) => void;
+    retryAttachment: (stagingId: string) => void;
+    clearAttachments: () => void;
+    isUploading: boolean;
+    readyAttachments: Array<IFileAttachment>;
+}
+/** The host registers the uploader that backs surfaces without a bucket of their own. */
+export declare const configureSharedFileUploader: (uploader: TFileUploader | null) => void;
+/**
+ * Staging area between picking a file and having a stored reference for it: upload progress,
+ * cancellation, retry and object-URL lifecycle. Whoever owns the surface decides what to do
+ * with `readyAttachments` (send them beside a message, or write them into the body).
+ */
+export declare const useFileAttachments: (options?: IUseFileAttachmentsOptions) => IUseFileAttachmentsResult;