@lucasbernardosn/ts-utils 0.0.0-stage → 0.2.0

package/dist/types/optional.d.ts

@@ -0,0 +1,29 @@
+//#region src/types/optional.d.ts
+/**
+ * Tipo utilitário que torna propriedades específicas opcionais, mantendo as demais inalteradas.
+ *
+ * @template TBase - Tipo base de referência.
+ * @template TOptionalKeys - Chaves de TBase que se tornarão opcionais.
+ *
+ * @example
+ *
+ * type Usuario = {
+ *   id: number;
+ *   nome: string;
+ *   email: string;
+ *   idade: number;
+ * };
+ *
+ * type UsuarioComIdOpcional = Optional<Usuario, 'id' | 'idade'>
+ *
+ * // Resultado:
+ * // {
+ * //   id?: number;
+ * //   nome: string;
+ * //   email: string;
+ * //   idade?: number;
+ * // }
+ */
+export type Optional<TBase, TOptionalKeys extends keyof TBase> = Pick<Partial<TBase>, TOptionalKeys> & Omit<TBase, TOptionalKeys>;
+//#endregion
+//# sourceMappingURL=optional.d.ts.map

package/dist/types/pick-by-value.d.ts

@@ -0,0 +1,30 @@
+import { KeysOfType } from "./keys-of-type.js";
+//#region src/types/pick-by-value.d.ts
+/**
+ * Tipo utilitário que seleciona apenas as propriedades de um objeto cujos valores
+ * estendem um tipo específico. Complemento do `Pick` nativo, que seleciona por chave.
+ *
+ * @template TBase - Tipo base a ser filtrado.
+ * @template TValue - Tipo dos valores que serão mantidos.
+ *
+ * @example
+ *
+ * type Usuario = {
+ *   id: number;
+ *   nome: string;
+ *   email: string;
+ *   ativo: boolean;
+ *   idade: number;
+ * };
+ *
+ * type ApenasStrings = PickByValue<Usuario, string>;
+ *
+ * // Resultado:
+ * // {
+ * //   nome: string;
+ * //   email: string;
+ * // }
+ */
+export type PickByValue<TBase, TValue> = Pick<TBase, KeysOfType<TBase, TValue>>;
+//#endregion
+//# sourceMappingURL=pick-by-value.d.ts.map

package/dist/types/recompose.d.ts

@@ -0,0 +1,26 @@
+//#region src/types/recompose.d.ts
+/**
+ * Tipo utilitário que força a expansão e exibição completa de um tipo,
+ * tornando-o mais legível nas ferramentas de desenvolvimento.
+ *
+ * @template TOriginal - Tipo a ser expandido e tornado mais legível.
+ *
+ * @example
+ *
+ * // Tipo complexo sem Recompose (pode aparecer colapsado em tooling)
+ * type UsuarioBase = { id: number; nome: string };
+ * type UsuarioComEmail = UsuarioBase & { email: string };
+ * type UsuarioCompleto = UsuarioComEmail & { ativo: boolean };
+ *
+ * // Sem Recompose, pode aparecer como:
+ * // UsuarioBase & UsuarioComEmail & { ativo: boolean }
+ * // ou
+ * // UsuarioBase & { email: string } & { ativo: boolean }
+ *
+ * // Com Recompose, fica expandido:
+ * type UsuarioExpandido = Recompose<UsuarioCompleto>;
+ * // Resultado: { id: number; nome: string; email: string; ativo: boolean }
+ */
+export type Recompose<TOriginal> = { [Key in keyof TOriginal]: TOriginal[Key]; } & {};
+//#endregion
+//# sourceMappingURL=recompose.d.ts.map

package/dist/types/required-except.d.ts

@@ -0,0 +1,31 @@
+import { Recompose } from "./recompose.js";
+//#region src/types/required-except.d.ts
+/**
+ * Tipo utilitário que cria um novo tipo baseado no tipo base passado, tornando todas as propriedades
+ * obrigatórias, exceto as especificadas em OptionalKeys que permanecem opcionais.
+ *
+ * @template TBase - Tipo base de referência.
+ * @template OptionalKeys - Chaves de TBase que permanecerão opcionais.
+ *
+ * @example
+ *
+ * type Usuario = {
+ *   id: number;
+ *   nome?: string;
+ *   login?: string;
+ *   idade?: number;
+ * };
+ *
+ * type UsuarioComIdadeOpcional = RequiredExcept<Usuario, 'idade'>;
+ *
+ * // Resultado:
+ * // {
+ * //   id: number;
+ * //   nome: string;
+ * //   login: string;
+ * //   idade?: number;
+ * // }
+ */
+export type RequiredExcept<TBase, OptionalKeys extends keyof TBase> = Recompose<Required<Omit<TBase, OptionalKeys>> & Partial<Pick<TBase, OptionalKeys>>>;
+//#endregion
+//# sourceMappingURL=required-except.d.ts.map

package/dist/types/serializable-value.d.ts

@@ -0,0 +1,23 @@
+//#region src/types/serializable-value.d.ts
+/**
+ * Tipo que representa um valor JSON válido, ou seja, que pode ser serializado
+ * de forma segura através de `JSON.stringify` e reconstruído com `JSON.parse`.
+ *
+ * Abrange funções e tipos primitivos suportados por JSON (string, número,
+ * booleano e null), além de arrays e objetos compostos por estes mesmos tipos.
+ *
+ * @example
+ *
+ * const data: SerializableValue = {
+ *   id: 1,
+ *   nome: "Usuário",
+ *   ativo: true,
+ *   metadados: null,
+ *   tags: ["typescript", "json"]
+ * };
+ */
+export type SerializableValue = string | number | boolean | null | SerializableValue[] | {
+  [key: string]: SerializableValue;
+};
+//#endregion
+//# sourceMappingURL=serializable-value.d.ts.map

package/dist/types/strict-empty-object.d.ts

@@ -0,0 +1,12 @@
+//#region src/types/strict-empty-object.d.ts
+/**
+ * Tipo que representa um objeto estritamente vazio, sem qualquer propriedade.
+ * Útil para tipar cenários onde um objeto literalmente vazio é esperado,
+ * rejeitando qualquer tentativa de acesso ou atribuição de propriedades.
+ *
+ * Diferente de `{}` (que permite qualquer propriedade), este tipo garante
+ * em tempo de compilação que o objeto não contenha nem mesmo chaves opcionais.
+ */
+export type StrictEmptyObject = Record<string, never>;
+//#endregion
+//# sourceMappingURL=strict-empty-object.d.ts.map

package/dist/types/unknown.d.ts

@@ -0,0 +1,33 @@
+//#region src/types/unknown.d.ts
+/**
+ * Tipo genérico que representa qualquer valor desconhecido no TypeScript.
+ * Utilizado quando o tipo específico não pode ser determinado antecipadamente,
+ * mas diferenciado de `any` por preservar verificações de tipo mais seguras.
+ */
+export type UnknownType = unknown;
+/**
+ * Tipo que representa um objeto genérico com chaves string e valores desconhecidos.
+ * Útil para modelar payloads ou estruturas dinâmicas onde as propriedades não são
+ * fixas ou não se conhece seus tipos em tempo de compilação.
+ */
+export type UnknownObject = Record<string, UnknownType>;
+/**
+ * Tipo que representa um array genérico contendo elementos de tipo desconhecido.
+ * Pode ser utilizado para modelar listas ou coleções onde o tipo dos elementos
+ * não é conhecido ou pode variar.
+ */
+export type UnknownArray = UnknownType[];
+/**
+ * Tipo que representa uma função genérica que recebe argumentos de tipo
+ * desconhecido e retorna um valor desconhecido.
+ */
+export type UnknownFunction = (...args: UnknownType[]) => UnknownType;
+/**
+ * Tipo que representa um valor frouxamente tipado, podendo ser um primitivo,
+ * `null`, `undefined`, um objeto ou array com valores desconhecidos. Útil para modelar
+ * valores de origem incerta que ainda assim têm um conjunto limitado de formas possíveis,
+ * preservando verificações de tipo mais seguras que `AnyLooseValue`.
+ */
+export type UnknownLooseValue = string | number | boolean | UnknownObject | UnknownArray | null | undefined;
+//#endregion
+//# sourceMappingURL=unknown.d.ts.map

package/dist/types/value-of.d.ts

@@ -0,0 +1,20 @@
+//#region src/types/value-of.d.ts
+/**
+ * Tipo utilitário que extrai a união de todos os tipos de valores de um objeto.
+ *
+ * @template TBase - Tipo base cujos valores serão extraídos.
+ *
+ * @example
+ *
+ * type Status = {
+ *   ativo: 'ativo';
+ *   inativo: 'inativo';
+ *   pendente: 'pendente';
+ * };
+ *
+ * type ValorStatus = ValueOf<Status>;
+ * // Resultado: 'ativo' | 'inativo' | 'pendente'
+ */
+export type ValueOf<TBase> = TBase[keyof TBase];
+//#endregion
+//# sourceMappingURL=value-of.d.ts.map

package/dist/utils/compose-event-handlers.d.ts

@@ -0,0 +1,18 @@
+//#region src/utils/compose-event-handlers.d.ts
+/**
+ * Combina múltiplos callbacks de eventos em um único handler, executando-os em sequência
+ * com os mesmos argumentos. Handlers `undefined` são ignorados silenciosamente.
+ *
+ * Projetado para uso em eventos de componentes, onde é comum precisar chamar um handler
+ * vindo de props junto com um handler interno — sem que um sobrescreva o outro.
+ *
+ * Os argumentos (`Args`) são inferidos dos callbacks ou do contexto de uso (ex: prop de evento do
+ * componente), o que permite escrever callbacks inline sem anotar os parâmetros manualmente.
+ *
+ * @template Args - Argumentos do handler de evento.
+ * @param callbacks - Um ou mais callbacks a serem executados em sequência. Aceita `undefined`.
+ * @returns Um único handler que chama todos os callbacks fornecidos na ordem recebida.
+ */
+export declare const composeEventHandlers: <Args extends unknown[]>(...callbacks: Array<((...args: Args) => void) | undefined>) => (...args: Args) => void;
+//#endregion
+//# sourceMappingURL=compose-event-handlers.d.ts.map

package/dist/utils/compose-event-handlers.js

@@ -0,0 +1,22 @@
+//#region src/utils/compose-event-handlers.ts
+/**
+* Combina múltiplos callbacks de eventos em um único handler, executando-os em sequência
+* com os mesmos argumentos. Handlers `undefined` são ignorados silenciosamente.
+*
+* Projetado para uso em eventos de componentes, onde é comum precisar chamar um handler
+* vindo de props junto com um handler interno — sem que um sobrescreva o outro.
+*
+* Os argumentos (`Args`) são inferidos dos callbacks ou do contexto de uso (ex: prop de evento do
+* componente), o que permite escrever callbacks inline sem anotar os parâmetros manualmente.
+*
+* @template Args - Argumentos do handler de evento.
+* @param callbacks - Um ou mais callbacks a serem executados em sequência. Aceita `undefined`.
+* @returns Um único handler que chama todos os callbacks fornecidos na ordem recebida.
+*/
+const composeEventHandlers = (...callbacks) => (...args) => {
+	for (const handler of callbacks) if (handler) handler(...args);
+};
+//#endregion
+export { composeEventHandlers };
+
+//# sourceMappingURL=compose-event-handlers.js.map

package/dist/utils/compose-event-handlers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compose-event-handlers.js","names":[],"sources":["../../src/utils/compose-event-handlers.ts"],"sourcesContent":["/**\n * Combina múltiplos callbacks de eventos em um único handler, executando-os em sequência\n * com os mesmos argumentos. Handlers `undefined` são ignorados silenciosamente.\n *\n * Projetado para uso em eventos de componentes, onde é comum precisar chamar um handler\n * vindo de props junto com um handler interno — sem que um sobrescreva o outro.\n *\n * Os argumentos (`Args`) são inferidos dos callbacks ou do contexto de uso (ex: prop de evento do\n * componente), o que permite escrever callbacks inline sem anotar os parâmetros manualmente.\n *\n * @template Args - Argumentos do handler de evento.\n * @param callbacks - Um ou mais callbacks a serem executados em sequência. Aceita `undefined`.\n * @returns Um único handler que chama todos os callbacks fornecidos na ordem recebida.\n */\nexport const composeEventHandlers =\n  <Args extends unknown[]>(\n    ...callbacks: Array<((...args: Args) => void) | undefined>\n  ) =>\n  (...args: Args): void => {\n    for (const handler of callbacks) {\n      // Handlers undefined são ignorados para permitir passar props opcionais diretamente\n      if (handler) {\n        handler(...args);\n      }\n    }\n  };\n"],"mappings":";;;;;;;;;;;;;;;AAcA,MAAa,wBAET,GAAG,eAEJ,GAAG,SAAqB;CACvB,KAAK,MAAM,WAAW,WAEpB,IAAI,SACF,QAAQ,GAAG,IAAI;AAGrB"}

package/dist/utils/create-split-props.d.ts

@@ -0,0 +1,38 @@
+//#region src/utils/create-split-props.d.ts
+/**
+ * Extrai as chaves de `Target` que ainda não foram cobertas por `ProvidedKeys`.
+ *
+ * @template Target - Objeto de referência cujas chaves são checadas.
+ * @template ProvidedKeys - Subconjunto de chaves de `Target` já fornecido.
+ */
+type MissingKeys<Target, ProvidedKeys extends keyof Target> = Exclude<keyof Target, ProvidedKeys>;
+/**
+ * Checagem de exaustividade em tempo de compilação: garante que `ProvidedKeys`
+ * cubra todas as chaves de `Target`. Quando falta alguma chave, o tipo vira uma
+ * mensagem de erro literal, fazendo o TypeScript reclamar no parâmetro `keys`
+ * de `createSplitProps`.
+ *
+ * @template ProvidedKeys - Lista de chaves de `Target` fornecida pelo chamador.
+ * @template Target - Objeto de referência cujas chaves devem ser totalmente cobertas.
+ */
+type EnsureAllKeysProvided<ProvidedKeys extends (keyof Target)[], Target> = keyof Target extends ProvidedKeys[number] ? unknown : `Missing required keys: ${MissingKeys<Target, ProvidedKeys[number]> & string}`;
+/**
+ * Cria uma função que separa um objeto de props em duas partes:
+ * - um objeto `Target`, contendo apenas as chaves informadas em `keys`;
+ * - o restante das props, tipado como `Omit<Props, Keys>`.
+ *
+ * `EnsureAllKeysProvided` obriga a lista `keys` a cobrir todas as chaves
+ * de `Target`, evitando esquecer alguma propriedade na divisão.
+ *
+ * @template Target - Forma do objeto que define quais chaves serão extraídas.
+ * @returns Função configurada para `Target` que recebe `props` e `keys` e devolve a divisão.
+ *
+ * @example
+ * ```ts
+ * type ButtonProps = { label: string; onClick: () => void }
+ * const [buttonProps, restProps] = createSplitProps<ButtonProps>()(props, ['label', 'onClick'])
+ * ```
+ */
+export declare const createSplitProps: <Target>() => <Keys extends (keyof Target)[], Props extends Target = Target>(props: Props, keys: Keys & EnsureAllKeysProvided<Keys, Target>) => [Target, Omit<Props, Extract<Keys[number], string>>];
+//#endregion
+//# sourceMappingURL=create-split-props.d.ts.map

package/dist/utils/create-split-props.js

@@ -0,0 +1,36 @@
+//#region src/utils/create-split-props.ts
+/**
+* Cria uma função que separa um objeto de props em duas partes:
+* - um objeto `Target`, contendo apenas as chaves informadas em `keys`;
+* - o restante das props, tipado como `Omit<Props, Keys>`.
+*
+* `EnsureAllKeysProvided` obriga a lista `keys` a cobrir todas as chaves
+* de `Target`, evitando esquecer alguma propriedade na divisão.
+*
+* @template Target - Forma do objeto que define quais chaves serão extraídas.
+* @returns Função configurada para `Target` que recebe `props` e `keys` e devolve a divisão.
+*
+* @example
+* ```ts
+* type ButtonProps = { label: string; onClick: () => void }
+* const [buttonProps, restProps] = createSplitProps<ButtonProps>()(props, ['label', 'onClick'])
+* ```
+*/
+const createSplitProps = () => (props, keys) => {
+	/**
+	* Os casts ficam porque o TypeScript não prova que copiar as chaves de uma lista monta um
+	* `Target` e deixa um `Omit<Props, KeyName>`: o objeto nasce vazio e cresce chave a chave. A
+	* garantia vem do `EnsureAllKeysProvided`, que obriga a lista a cobrir todo o `Target`.
+	*/
+	return keys.reduce((splitResult, keyName) => {
+		const [pickedProps, remainingProps] = splitResult;
+		const typedKey = keyName;
+		if (remainingProps[typedKey] !== void 0) pickedProps[typedKey] = remainingProps[typedKey];
+		delete remainingProps[typedKey];
+		return splitResult;
+	}, [{}, { ...props }]);
+};
+//#endregion
+export { createSplitProps };
+
+//# sourceMappingURL=create-split-props.js.map

package/dist/utils/create-split-props.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-split-props.js","names":[],"sources":["../../src/utils/create-split-props.ts"],"sourcesContent":["/**\n * Extrai as chaves de `Target` que ainda não foram cobertas por `ProvidedKeys`.\n *\n * @template Target - Objeto de referência cujas chaves são checadas.\n * @template ProvidedKeys - Subconjunto de chaves de `Target` já fornecido.\n */\ntype MissingKeys<Target, ProvidedKeys extends keyof Target> = Exclude<\n  keyof Target,\n  ProvidedKeys\n>;\n\n/**\n * Checagem de exaustividade em tempo de compilação: garante que `ProvidedKeys`\n * cubra todas as chaves de `Target`. Quando falta alguma chave, o tipo vira uma\n * mensagem de erro literal, fazendo o TypeScript reclamar no parâmetro `keys`\n * de `createSplitProps`.\n *\n * @template ProvidedKeys - Lista de chaves de `Target` fornecida pelo chamador.\n * @template Target - Objeto de referência cujas chaves devem ser totalmente cobertas.\n */\ntype EnsureAllKeysProvided<\n  ProvidedKeys extends (keyof Target)[],\n  Target,\n> = keyof Target extends ProvidedKeys[number]\n  ? unknown\n  : `Missing required keys: ${MissingKeys<Target, ProvidedKeys[number]> & string}`;\n\n/**\n * Cria uma função que separa um objeto de props em duas partes:\n * - um objeto `Target`, contendo apenas as chaves informadas em `keys`;\n * - o restante das props, tipado como `Omit<Props, Keys>`.\n *\n * `EnsureAllKeysProvided` obriga a lista `keys` a cobrir todas as chaves\n * de `Target`, evitando esquecer alguma propriedade na divisão.\n *\n * @template Target - Forma do objeto que define quais chaves serão extraídas.\n * @returns Função configurada para `Target` que recebe `props` e `keys` e devolve a divisão.\n *\n * @example\n * ```ts\n * type ButtonProps = { label: string; onClick: () => void }\n * const [buttonProps, restProps] = createSplitProps<ButtonProps>()(props, ['label', 'onClick'])\n * ```\n */\nexport const createSplitProps =\n  <Target>() =>\n  /**\n   * @template Keys - Tupla das chaves de `Target` a extrair, deve cobri-lo por completo.\n   * @template Props - Tipo do objeto de entrada, deve estender `Target`.\n   * @param props - Objeto de props a ser dividido.\n   * @param keys - Lista de chaves de `Target` a extrair para o primeiro item do retorno.\n   * @returns Tupla `[pickedProps, remainingProps]` com as chaves extraídas e o restante.\n   */\n  <Keys extends (keyof Target)[], Props extends Target = Target>(\n    props: Props,\n    keys: Keys & EnsureAllKeysProvided<Keys, Target>,\n  ) => {\n    type KeyName = Extract<Keys[number], string>;\n\n    /**\n     * Os casts ficam porque o TypeScript não prova que copiar as chaves de uma lista monta um\n     * `Target` e deixa um `Omit<Props, KeyName>`: o objeto nasce vazio e cresce chave a chave. A\n     * garantia vem do `EnsureAllKeysProvided`, que obriga a lista a cobrir todo o `Target`.\n     */\n    // biome-ignore lint/nursery/noUnsafeTypeAssertion: ver o comentário acima do `return`\n    return (keys as string[]).reduce<[Target, Omit<Props, KeyName>]>(\n      (splitResult, keyName) => {\n        const [pickedProps, remainingProps] = splitResult;\n\n        // biome-ignore lint/nursery/noUnsafeTypeAssertion: ver o comentário acima do `return`\n        const typedKey = keyName as keyof Target & keyof typeof remainingProps;\n\n        if (remainingProps[typedKey] !== undefined) {\n          pickedProps[typedKey] = remainingProps[typedKey];\n        }\n\n        delete remainingProps[typedKey];\n\n        return splitResult;\n      },\n      // biome-ignore lint/nursery/noUnsafeTypeAssertion: ver o comentário acima do `return`\n      [{} as Target, { ...props }],\n    );\n  };\n"],"mappings":";;;;;;;;;;;;;;;;;;AA4CA,MAAa,0BAUT,OACA,SACG;;;;;;CASH,OAAQ,KAAkB,QACvB,aAAa,YAAY;EACxB,MAAM,CAAC,aAAa,kBAAkB;EAGtC,MAAM,WAAW;EAEjB,IAAI,eAAe,cAAc,KAAA,GAC/B,YAAY,YAAY,eAAe;EAGzC,OAAO,eAAe;EAEtB,OAAO;CACT,GAEA,CAAC,CAAC,GAAa,EAAE,GAAG,MAAM,CAAC,CAC7B;AACF"}

package/dist/utils/get-initials.d.ts

@@ -0,0 +1,15 @@
+//#region src/utils/get-initials.d.ts
+/**
+ * Iniciais de um nome, em maiúsculas: a primeira letra do primeiro e a do último nome, ou só a do
+ * primeiro quando há um nome só. Um nome vazio devolve string vazia.
+ *
+ * A primeira letra é lida por caractere, não por unidade de UTF-16: um nome que começa com emoji
+ * ou outro caractere fora do plano básico não sai cortado ao meio.
+ *
+ * @example
+ * getInitials('Lucas Bernardo da Silva') // 'LS'
+ * getInitials('lucas') // 'L'
+ */
+export declare const getInitials: (name: string) => string;
+//#endregion
+//# sourceMappingURL=get-initials.d.ts.map

package/dist/utils/get-initials.js

@@ -0,0 +1,21 @@
+//#region src/utils/get-initials.ts
+const WORD_SEPARATOR = /\s+/;
+/**
+* Iniciais de um nome, em maiúsculas: a primeira letra do primeiro e a do último nome, ou só a do
+* primeiro quando há um nome só. Um nome vazio devolve string vazia.
+*
+* A primeira letra é lida por caractere, não por unidade de UTF-16: um nome que começa com emoji
+* ou outro caractere fora do plano básico não sai cortado ao meio.
+*
+* @example
+* getInitials('Lucas Bernardo da Silva') // 'LS'
+* getInitials('lucas') // 'L'
+*/
+const getInitials = (name) => {
+	const words = name.trim().split(WORD_SEPARATOR).filter(Boolean);
+	return [words.at(0), words.length > 1 ? words.at(-1) : void 0].map((word) => word === void 0 ? "" : Array.from(word).at(0) ?? "").join("").toUpperCase();
+};
+//#endregion
+export { getInitials };
+
+//# sourceMappingURL=get-initials.js.map

package/dist/utils/get-initials.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-initials.js","names":[],"sources":["../../src/utils/get-initials.ts"],"sourcesContent":["const WORD_SEPARATOR = /\\s+/;\n\n/**\n * Iniciais de um nome, em maiúsculas: a primeira letra do primeiro e a do último nome, ou só a do\n * primeiro quando há um nome só. Um nome vazio devolve string vazia.\n *\n * A primeira letra é lida por caractere, não por unidade de UTF-16: um nome que começa com emoji\n * ou outro caractere fora do plano básico não sai cortado ao meio.\n *\n * @example\n * getInitials('Lucas Bernardo da Silva') // 'LS'\n * getInitials('lucas') // 'L'\n */\nexport const getInitials = (name: string) => {\n  const words = name.trim().split(WORD_SEPARATOR).filter(Boolean);\n\n  const firstWord = words.at(0);\n  const lastWord = words.length > 1 ? words.at(-1) : undefined;\n\n  return [firstWord, lastWord]\n    .map((word) => (word === undefined ? '' : (Array.from(word).at(0) ?? '')))\n    .join('')\n    .toUpperCase();\n};\n"],"mappings":";AAAA,MAAM,iBAAiB;;;;;;;;;;;;AAavB,MAAa,eAAe,SAAiB;CAC3C,MAAM,QAAQ,KAAK,KAAK,CAAC,CAAC,MAAM,cAAc,CAAC,CAAC,OAAO,OAAO;CAK9D,OAAO,CAHW,MAAM,GAAG,CAGX,GAFC,MAAM,SAAS,IAAI,MAAM,GAAG,EAAE,IAAI,KAAA,CAExB,CAAC,CACzB,KAAK,SAAU,SAAS,KAAA,IAAY,KAAM,MAAM,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,EAAI,CAAC,CACzE,KAAK,EAAE,CAAC,CACR,YAAY;AACjB"}

package/dist/utils/index.d.ts

@@ -0,0 +1,8 @@
+import { composeEventHandlers } from "./compose-event-handlers.js";
+import { createSplitProps } from "./create-split-props.js";
+import { getInitials } from "./get-initials.js";
+import { isDeepEqual } from "./is-deep-equal.js";
+import { isNotNullish } from "./is-not-nullish.js";
+import { mergeBooleansAnd, mergeBooleansOr } from "./merge-booleans.js";
+import { PascalCase, toPascalCase } from "./to-pascal-case.js";
+export { PascalCase, composeEventHandlers, createSplitProps, getInitials, isDeepEqual, isNotNullish, mergeBooleansAnd, mergeBooleansOr, toPascalCase };

package/dist/utils/index.js

@@ -0,0 +1,8 @@
+import { composeEventHandlers } from "./compose-event-handlers.js";
+import { createSplitProps } from "./create-split-props.js";
+import { getInitials } from "./get-initials.js";
+import { isDeepEqual } from "./is-deep-equal.js";
+import { isNotNullish } from "./is-not-nullish.js";
+import { mergeBooleansAnd, mergeBooleansOr } from "./merge-booleans.js";
+import { toPascalCase } from "./to-pascal-case.js";
+export { composeEventHandlers, createSplitProps, getInitials, isDeepEqual, isNotNullish, mergeBooleansAnd, mergeBooleansOr, toPascalCase };

package/dist/utils/is-deep-equal.d.ts

@@ -0,0 +1,24 @@
+//#region src/utils/is-deep-equal.d.ts
+/**
+ * Compara dois valores por igualdade profunda (deep equality).
+ *
+ * Suporta todos os tipos nativos do JavaScript:
+ * primitivos, `Date`, `RegExp`, `Array`, `Set`, `Map`,
+ * `ArrayBuffer`, `DataView`, TypedArrays e objetos genéricos.
+ *
+ * **Atenção:** não suporta referências circulares — causam stack overflow.
+ *
+ * @param valueA - Primeiro valor a ser comparado
+ * @param valueB - Segundo valor a ser comparado
+ * @returns `true` se os valores forem profundamente iguais, `false` caso contrário
+ *
+ * @example
+ * isDeepEqual({ a: 1 }, { a: 1 })          // true
+ * isDeepEqual([1, [2]], [1, [2]])           // true
+ * isDeepEqual(NaN, NaN)                     // true
+ * isDeepEqual(new Date('2024'), new Date('2024')) // true
+ * isDeepEqual({ a: 1 }, { a: 2 })          // false
+ */
+export declare const isDeepEqual: (valueA: unknown, valueB: unknown) => boolean;
+//#endregion
+//# sourceMappingURL=is-deep-equal.d.ts.map

package/dist/utils/is-deep-equal.js

@@ -0,0 +1,110 @@
+//#region src/utils/is-deep-equal.ts
+/**
+* Compara dois valores por igualdade profunda (deep equality).
+*
+* Suporta todos os tipos nativos do JavaScript:
+* primitivos, `Date`, `RegExp`, `Array`, `Set`, `Map`,
+* `ArrayBuffer`, `DataView`, TypedArrays e objetos genéricos.
+*
+* **Atenção:** não suporta referências circulares — causam stack overflow.
+*
+* @param valueA - Primeiro valor a ser comparado
+* @param valueB - Segundo valor a ser comparado
+* @returns `true` se os valores forem profundamente iguais, `false` caso contrário
+*
+* @example
+* isDeepEqual({ a: 1 }, { a: 1 })          // true
+* isDeepEqual([1, [2]], [1, [2]])           // true
+* isDeepEqual(NaN, NaN)                     // true
+* isDeepEqual(new Date('2024'), new Date('2024')) // true
+* isDeepEqual({ a: 1 }, { a: 2 })          // false
+*/
+const isDeepEqual = (valueA, valueB) => {
+	if (valueA === valueB) return true;
+	/**
+	* Fora de dois objetos, só sobra o `NaN`, o único valor diferente de si mesmo. `null` entra aqui
+	* porque `typeof null` é `'object'`: sem a checagem, ele chegaria ao `.constructor`.
+	*/
+	if (typeof valueA !== "object" || typeof valueB !== "object" || valueA === null || valueB === null) return valueA !== valueA && valueB !== valueB;
+	/**
+	* O mesmo construtor separa instâncias de classes diferentes com as mesmas chaves, e um Array de
+	* um objeto com índices. Os `instanceof` abaixo só estreitam o tipo para o TypeScript.
+	*/
+	if (valueA.constructor !== valueB.constructor) return false;
+	if (valueA instanceof Date && valueB instanceof Date) return valueA.getTime() === valueB.getTime();
+	if (valueA instanceof RegExp && valueB instanceof RegExp) return valueA.toString() === valueB.toString();
+	/** Array: só `length` e os itens por índice, sem as outras propriedades próprias. */
+	if (Array.isArray(valueA) && Array.isArray(valueB)) {
+		const arrayA = valueA;
+		const arrayB = valueB;
+		if (arrayA.length !== arrayB.length) return false;
+		/** Laço por índice, não `every`: o `every` pula os buracos de um array esparso. */
+		for (let index = 0; index < arrayA.length; index++) if (!isDeepEqual(arrayA[index], arrayB[index])) return false;
+		return true;
+	}
+	/**
+	* Set e Map: itens e chaves que são objetos precisam de busca por igualdade profunda, porque o
+	* `has` só acha a mesma referência.
+	*/
+	if (valueA instanceof Set && valueB instanceof Set) {
+		const setA = valueA;
+		const setB = valueB;
+		if (setA.size !== setB.size) return false;
+		for (const item of setA) {
+			const resolvedItem = item && typeof item === "object" ? findDeepEqualKey(setB, item) : item;
+			if (resolvedItem === void 0 || !setB.has(resolvedItem)) return false;
+		}
+		return true;
+	}
+	if (valueA instanceof Map && valueB instanceof Map) {
+		const mapA = valueA;
+		const mapB = valueB;
+		if (mapA.size !== mapB.size) return false;
+		for (const [keyA, entryValueA] of mapA) {
+			const resolvedKey = keyA && typeof keyA === "object" ? findDeepEqualKey(mapB, keyA) : keyA;
+			if (resolvedKey === void 0) return false;
+			if (!isDeepEqual(entryValueA, mapB.get(resolvedKey))) return false;
+		}
+		return true;
+	}
+	/**
+	* ArrayBuffer, DataView e TypedArrays comparam byte a byte. Num array de ponto flutuante, `0` e
+	* `-0` têm bytes diferentes e contam como diferentes.
+	*/
+	if (valueA instanceof ArrayBuffer && valueB instanceof ArrayBuffer) return areBytesEqual(new Uint8Array(valueA), new Uint8Array(valueB));
+	if (ArrayBuffer.isView(valueA) && ArrayBuffer.isView(valueB)) return areBytesEqual(toBytes(valueA), toBytes(valueB));
+	/**
+	* Objetos genéricos (literais, instâncias de classe, `Object.create(null)`): as chaves próprias
+	* enumeráveis, em qualquer ordem. WeakMap e WeakSet não têm chaves visíveis e sempre saem iguais.
+	*/
+	const entriesA = Object.entries(valueA);
+	if (entriesA.length !== Object.keys(valueB).length) return false;
+	const entriesB = new Map(Object.entries(valueB));
+	return entriesA.every(([key, entryValueA]) => entriesB.has(key) && isDeepEqual(entryValueA, entriesB.get(key)));
+};
+/**
+* Os bytes que uma view (TypedArray ou DataView) enxerga no buffer dela.
+*/
+const toBytes = (view) => new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+/**
+* Compara dois blocos de bytes, posição por posição.
+*/
+const areBytesEqual = (bytesA, bytesB) => bytesA.length === bytesB.length && bytesA.every((byte, index) => byte === bytesB[index]);
+/**
+* Busca, dentro de um iterável (Set ou Map), uma chave que seja
+* profundamente igual ao alvo informado.
+*
+* Necessário para comparar chaves de objetos dentro de Sets/Maps,
+* já que a igualdade referencial nativa não é suficiente nesses casos.
+*
+* @param iterable - O Set ou Map cujas chaves serão percorridas
+* @param target - O valor alvo a ser encontrado por igualdade profunda
+* @returns A chave encontrada ou `undefined` caso não exista
+*/
+const findDeepEqualKey = (iterable, target) => {
+	for (const key of iterable.keys()) if (isDeepEqual(key, target)) return key;
+};
+//#endregion
+export { isDeepEqual };
+
+//# sourceMappingURL=is-deep-equal.js.map

package/dist/utils/is-deep-equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-deep-equal.js","names":[],"sources":["../../src/utils/is-deep-equal.ts"],"sourcesContent":["/**\n * Compara dois valores por igualdade profunda (deep equality).\n *\n * Suporta todos os tipos nativos do JavaScript:\n * primitivos, `Date`, `RegExp`, `Array`, `Set`, `Map`,\n * `ArrayBuffer`, `DataView`, TypedArrays e objetos genéricos.\n *\n * **Atenção:** não suporta referências circulares — causam stack overflow.\n *\n * @param valueA - Primeiro valor a ser comparado\n * @param valueB - Segundo valor a ser comparado\n * @returns `true` se os valores forem profundamente iguais, `false` caso contrário\n *\n * @example\n * isDeepEqual({ a: 1 }, { a: 1 })          // true\n * isDeepEqual([1, [2]], [1, [2]])           // true\n * isDeepEqual(NaN, NaN)                     // true\n * isDeepEqual(new Date('2024'), new Date('2024')) // true\n * isDeepEqual({ a: 1 }, { a: 2 })          // false\n */\nexport const isDeepEqual = (valueA: unknown, valueB: unknown): boolean => {\n  if (valueA === valueB) {\n    return true;\n  }\n\n  /**\n   * Fora de dois objetos, só sobra o `NaN`, o único valor diferente de si mesmo. `null` entra aqui\n   * porque `typeof null` é `'object'`: sem a checagem, ele chegaria ao `.constructor`.\n   */\n  if (\n    typeof valueA !== 'object' ||\n    typeof valueB !== 'object' ||\n    valueA === null ||\n    valueB === null\n  ) {\n    // biome-ignore lint/suspicious/noSelfCompare: comparação intencional para detectar NaN\n    return valueA !== valueA && valueB !== valueB;\n  }\n\n  /**\n   * O mesmo construtor separa instâncias de classes diferentes com as mesmas chaves, e um Array de\n   * um objeto com índices. Os `instanceof` abaixo só estreitam o tipo para o TypeScript.\n   */\n  if (valueA.constructor !== valueB.constructor) {\n    return false;\n  }\n\n  if (valueA instanceof Date && valueB instanceof Date) {\n    return valueA.getTime() === valueB.getTime();\n  }\n\n  if (valueA instanceof RegExp && valueB instanceof RegExp) {\n    return valueA.toString() === valueB.toString();\n  }\n\n  /** Array: só `length` e os itens por índice, sem as outras propriedades próprias. */\n  if (Array.isArray(valueA) && Array.isArray(valueB)) {\n    const arrayA: readonly unknown[] = valueA;\n    const arrayB: readonly unknown[] = valueB;\n\n    if (arrayA.length !== arrayB.length) {\n      return false;\n    }\n\n    /** Laço por índice, não `every`: o `every` pula os buracos de um array esparso. */\n    for (let index = 0; index < arrayA.length; index++) {\n      if (!isDeepEqual(arrayA[index], arrayB[index])) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * Set e Map: itens e chaves que são objetos precisam de busca por igualdade profunda, porque o\n   * `has` só acha a mesma referência.\n   */\n  if (valueA instanceof Set && valueB instanceof Set) {\n    const setA: ReadonlySet<unknown> = valueA;\n    const setB: ReadonlySet<unknown> = valueB;\n\n    if (setA.size !== setB.size) {\n      return false;\n    }\n\n    for (const item of setA) {\n      const resolvedItem =\n        item && typeof item === 'object' ? findDeepEqualKey(setB, item) : item;\n\n      if (resolvedItem === undefined || !setB.has(resolvedItem)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  if (valueA instanceof Map && valueB instanceof Map) {\n    const mapA: ReadonlyMap<unknown, unknown> = valueA;\n    const mapB: ReadonlyMap<unknown, unknown> = valueB;\n\n    if (mapA.size !== mapB.size) {\n      return false;\n    }\n\n    for (const [keyA, entryValueA] of mapA) {\n      const resolvedKey =\n        keyA && typeof keyA === 'object' ? findDeepEqualKey(mapB, keyA) : keyA;\n\n      if (resolvedKey === undefined) {\n        return false;\n      }\n\n      if (!isDeepEqual(entryValueA, mapB.get(resolvedKey))) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  /**\n   * ArrayBuffer, DataView e TypedArrays comparam byte a byte. Num array de ponto flutuante, `0` e\n   * `-0` têm bytes diferentes e contam como diferentes.\n   */\n  if (valueA instanceof ArrayBuffer && valueB instanceof ArrayBuffer) {\n    return areBytesEqual(new Uint8Array(valueA), new Uint8Array(valueB));\n  }\n\n  if (ArrayBuffer.isView(valueA) && ArrayBuffer.isView(valueB)) {\n    return areBytesEqual(toBytes(valueA), toBytes(valueB));\n  }\n\n  /**\n   * Objetos genéricos (literais, instâncias de classe, `Object.create(null)`): as chaves próprias\n   * enumeráveis, em qualquer ordem. WeakMap e WeakSet não têm chaves visíveis e sempre saem iguais.\n   */\n  const entriesA: [string, unknown][] = Object.entries(valueA);\n\n  if (entriesA.length !== Object.keys(valueB).length) {\n    return false;\n  }\n\n  const entriesB = new Map<string, unknown>(Object.entries(valueB));\n\n  return entriesA.every(\n    ([key, entryValueA]) =>\n      entriesB.has(key) && isDeepEqual(entryValueA, entriesB.get(key)),\n  );\n};\n\n/**\n * Os bytes que uma view (TypedArray ou DataView) enxerga no buffer dela.\n */\nconst toBytes = (view: ArrayBufferView): Uint8Array =>\n  new Uint8Array(view.buffer, view.byteOffset, view.byteLength);\n\n/**\n * Compara dois blocos de bytes, posição por posição.\n */\nconst areBytesEqual = (bytesA: Uint8Array, bytesB: Uint8Array): boolean =>\n  bytesA.length === bytesB.length &&\n  bytesA.every((byte, index) => byte === bytesB[index]);\n\n/**\n * Busca, dentro de um iterável (Set ou Map), uma chave que seja\n * profundamente igual ao alvo informado.\n *\n * Necessário para comparar chaves de objetos dentro de Sets/Maps,\n * já que a igualdade referencial nativa não é suficiente nesses casos.\n *\n * @param iterable - O Set ou Map cujas chaves serão percorridas\n * @param target - O valor alvo a ser encontrado por igualdade profunda\n * @returns A chave encontrada ou `undefined` caso não exista\n */\nconst findDeepEqualKey = (\n  iterable: ReadonlySet<unknown> | ReadonlyMap<unknown, unknown>,\n  target: unknown,\n): unknown => {\n  for (const key of iterable.keys()) {\n    if (isDeepEqual(key, target)) {\n      return key;\n    }\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAoBA,MAAa,eAAe,QAAiB,WAA6B;CACxE,IAAI,WAAW,QACb,OAAO;;;;;CAOT,IACE,OAAO,WAAW,YAClB,OAAO,WAAW,YAClB,WAAW,QACX,WAAW,MAGX,OAAO,WAAW,UAAU,WAAW;;;;;CAOzC,IAAI,OAAO,gBAAgB,OAAO,aAChC,OAAO;CAGT,IAAI,kBAAkB,QAAQ,kBAAkB,MAC9C,OAAO,OAAO,QAAQ,MAAM,OAAO,QAAQ;CAG7C,IAAI,kBAAkB,UAAU,kBAAkB,QAChD,OAAO,OAAO,SAAS,MAAM,OAAO,SAAS;;CAI/C,IAAI,MAAM,QAAQ,MAAM,KAAK,MAAM,QAAQ,MAAM,GAAG;EAClD,MAAM,SAA6B;EACnC,MAAM,SAA6B;EAEnC,IAAI,OAAO,WAAW,OAAO,QAC3B,OAAO;;EAIT,KAAK,IAAI,QAAQ,GAAG,QAAQ,OAAO,QAAQ,SACzC,IAAI,CAAC,YAAY,OAAO,QAAQ,OAAO,MAAM,GAC3C,OAAO;EAIX,OAAO;CACT;;;;;CAMA,IAAI,kBAAkB,OAAO,kBAAkB,KAAK;EAClD,MAAM,OAA6B;EACnC,MAAM,OAA6B;EAEnC,IAAI,KAAK,SAAS,KAAK,MACrB,OAAO;EAGT,KAAK,MAAM,QAAQ,MAAM;GACvB,MAAM,eACJ,QAAQ,OAAO,SAAS,WAAW,iBAAiB,MAAM,IAAI,IAAI;GAEpE,IAAI,iBAAiB,KAAA,KAAa,CAAC,KAAK,IAAI,YAAY,GACtD,OAAO;EAEX;EAEA,OAAO;CACT;CAEA,IAAI,kBAAkB,OAAO,kBAAkB,KAAK;EAClD,MAAM,OAAsC;EAC5C,MAAM,OAAsC;EAE5C,IAAI,KAAK,SAAS,KAAK,MACrB,OAAO;EAGT,KAAK,MAAM,CAAC,MAAM,gBAAgB,MAAM;GACtC,MAAM,cACJ,QAAQ,OAAO,SAAS,WAAW,iBAAiB,MAAM,IAAI,IAAI;GAEpE,IAAI,gBAAgB,KAAA,GAClB,OAAO;GAGT,IAAI,CAAC,YAAY,aAAa,KAAK,IAAI,WAAW,CAAC,GACjD,OAAO;EAEX;EAEA,OAAO;CACT;;;;;CAMA,IAAI,kBAAkB,eAAe,kBAAkB,aACrD,OAAO,cAAc,IAAI,WAAW,MAAM,GAAG,IAAI,WAAW,MAAM,CAAC;CAGrE,IAAI,YAAY,OAAO,MAAM,KAAK,YAAY,OAAO,MAAM,GACzD,OAAO,cAAc,QAAQ,MAAM,GAAG,QAAQ,MAAM,CAAC;;;;;CAOvD,MAAM,WAAgC,OAAO,QAAQ,MAAM;CAE3D,IAAI,SAAS,WAAW,OAAO,KAAK,MAAM,CAAC,CAAC,QAC1C,OAAO;CAGT,MAAM,WAAW,IAAI,IAAqB,OAAO,QAAQ,MAAM,CAAC;CAEhE,OAAO,SAAS,OACb,CAAC,KAAK,iBACL,SAAS,IAAI,GAAG,KAAK,YAAY,aAAa,SAAS,IAAI,GAAG,CAAC,CACnE;AACF;;;;AAKA,MAAM,WAAW,SACf,IAAI,WAAW,KAAK,QAAQ,KAAK,YAAY,KAAK,UAAU;;;;AAK9D,MAAM,iBAAiB,QAAoB,WACzC,OAAO,WAAW,OAAO,UACzB,OAAO,OAAO,MAAM,UAAU,SAAS,OAAO,MAAM;;;;;;;;;;;;AAatD,MAAM,oBACJ,UACA,WACY;CACZ,KAAK,MAAM,OAAO,SAAS,KAAK,GAC9B,IAAI,YAAY,KAAK,MAAM,GACzB,OAAO;AAGb"}

package/dist/utils/is-not-nullish.d.ts

@@ -0,0 +1,14 @@
+//#region src/utils/is-not-nullish.d.ts
+/**
+ * Type guard que verifica se um valor não é `null` nem `undefined`.
+ *
+ * @param value - Valor a ser verificado.
+ * @returns `true` se `value` não for `null` nem `undefined`.
+ *
+ * @example
+ * const values: (string | null | undefined)[] = ['a', null, 'b', undefined];
+ * const filtered: string[] = values.filter(isNotNullish);
+ */
+export declare const isNotNullish: <TValue>(value: TValue | null | undefined) => value is TValue;
+//#endregion
+//# sourceMappingURL=is-not-nullish.d.ts.map

package/dist/utils/is-not-nullish.js

@@ -0,0 +1,18 @@
+//#region src/utils/is-not-nullish.ts
+/**
+* Type guard que verifica se um valor não é `null` nem `undefined`.
+*
+* @param value - Valor a ser verificado.
+* @returns `true` se `value` não for `null` nem `undefined`.
+*
+* @example
+* const values: (string | null | undefined)[] = ['a', null, 'b', undefined];
+* const filtered: string[] = values.filter(isNotNullish);
+*/
+const isNotNullish = (value) => {
+	return value !== null && value !== void 0;
+};
+//#endregion
+export { isNotNullish };
+
+//# sourceMappingURL=is-not-nullish.js.map

package/dist/utils/is-not-nullish.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-not-nullish.js","names":[],"sources":["../../src/utils/is-not-nullish.ts"],"sourcesContent":["/**\n * Type guard que verifica se um valor não é `null` nem `undefined`.\n *\n * @param value - Valor a ser verificado.\n * @returns `true` se `value` não for `null` nem `undefined`.\n *\n * @example\n * const values: (string | null | undefined)[] = ['a', null, 'b', undefined];\n * const filtered: string[] = values.filter(isNotNullish);\n */\nexport const isNotNullish = <TValue>(\n  value: TValue | null | undefined,\n): value is TValue => {\n  return value !== null && value !== undefined;\n};\n"],"mappings":";;;;;;;;;;;AAUA,MAAa,gBACX,UACoB;CACpB,OAAO,UAAU,QAAQ,UAAU,KAAA;AACrC"}