@vef-framework/shared 2.0.11 → 2.1.0

package/dist/types/src/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './color-names';
+export * from './color-palettes';

package/dist/types/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './color';
+export * from './constants';
+export * from './types';
+export * from './utils';

package/dist/types/src/types/color.d.ts

@@ -0,0 +1,25 @@
+export type ColorEntry = [hex: string, name: string];
+export type ColorNumber = 50 | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | 950;
+export interface ColorSwatch {
+    number: ColorNumber;
+    hex: string;
+}
+export interface ColorPalette {
+    name: string;
+    swatches: ColorSwatch[];
+}
+export interface ColorSwatchWithDelta extends ColorSwatch {
+    delta: number;
+}
+export interface NearestColorPalette extends ColorPalette {
+    nearestSwatch: ColorSwatchWithDelta;
+    nearestLightnessSwatch: ColorSwatchWithDelta;
+}
+export interface MatchedColorPalette extends ColorPalette {
+    colorMap: Map<ColorNumber, string>;
+    /**
+     * The main color swatch with number 500
+     */
+    main: ColorSwatch;
+    matched: ColorSwatch;
+}

package/dist/types/src/types/common.d.ts

@@ -0,0 +1,29 @@
+import { Primitive } from 'type-fest';
+export type Builtin = Primitive | Function | Date | Error | RegExp;
+export type Key = string;
+export type Awaitable<T> = T | Promise<T>;
+export type MaybeArray<T> = T | T[];
+export type MaybeNullish<T> = T | null | undefined;
+export type MaybeUndefined<T> = T | undefined;
+export type MaybeNull<T> = T | null;
+export type IsString<T> = T extends string ? true : false;
+/**
+ * Inverts a boolean type.
+ *
+ * @example Not<true> = false, Not<false> = true
+ */
+export type Not<A extends boolean> = A extends true ? false : A extends false ? true : never;
+export interface EmptyObject {
+}
+export type AnyObject = Record<keyof any, any>;
+export type RenameKey<T, TOldKey extends keyof T, TNewKey extends string> = {
+    [K in keyof T as K extends TOldKey ? TNewKey : K]: T[K];
+};
+export type NonFunctionGuard<T> = T extends Function ? never : T;
+/**
+ * Omits all symbol keys from an object type.
+ */
+export type OmitSymbol<T> = {
+    [K in keyof T as K extends symbol ? never : K]: T[K];
+};
+export type { And, Except, HasOptionalKeys, HasRequiredKeys, If, IsAny, IsBooleanLiteral, IsEqual, IsFloat, IsInteger, IsLiteral, IsNever, IsNull, IsNullable, IsNumericLiteral, IsOptional, IsOptionalKeyOf, IsReadonlyKeyOf, IsRequiredKeyOf, IsStringLiteral, IsSymbolLiteral, IsTuple, IsUndefined, IsUnknown, IsWritableKeyOf, IterableElement, KebabCase, LiteralUnion, NonEmptyObject, NonEmptyString, NonEmptyTuple, OptionalKeysOf, Or, OverrideProperties, PartialDeep, Primitive, RequiredDeep, RequiredKeysOf, SetFieldType, SetOptional, SetParameterType, SetReadonly, SetRequired, SetReturnType, Simplify, SimplifyDeep } from 'type-fest';

package/dist/types/src/types/deep-keys.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Generates a range of numbers from 0 to N-1 as a tuple type.
+ * Used to create a union of valid array indices.
+ */
+type ComputeRange<N extends number, Result extends unknown[] = []> = Result["length"] extends N ? Result : ComputeRange<N, [...Result, Result["length"]]>;
+/**
+ * Union type of numbers from 0 to 39.
+ * Limits tuple index depth to prevent excessive type recursion.
+ */
+type Index40 = ComputeRange<40>[number];
+/**
+ * Checks if a type is a tuple (fixed-length array) with length <= 40.
+ * Returns the tuple type if valid, never otherwise.
+ */
+type IsTuple<T> = T extends readonly any[] & {
+    length: infer Length;
+} ? Length extends Index40 ? T : never : never;
+/**
+ * Extracts all valid numeric indices from a tuple type.
+ * For [string, number, boolean], returns 0 | 1 | 2.
+ */
+type AllowedIndexes<Tuple extends readonly any[], Keys extends number = never> = Tuple extends readonly [] ? Keys : Tuple extends readonly [infer _, ...infer Tail] ? AllowedIndexes<Tail, Keys | Tail["length"]> : Keys;
+/**
+ * Creates dot-notation paths for nested properties.
+ * Converts TPrefix.NestedKey into string literal types.
+ */
+type DeepKeysPrefix<T, TPrefix, TDepth extends any[]> = TPrefix extends keyof T & (number | string) ? `${TPrefix}.${DeepKeys<T[TPrefix], [...TDepth, any]> & string}` : never;
+/**
+ * Extracts all possible deep property paths from an object type as dot-notation strings.
+ * Supports nested objects, tuples, and arrays up to 5 levels deep.
+ *
+ * @example
+ * type User = { name: string; address: { city: string; zip: number } };
+ * type Paths = DeepKeys<User>; // "name" | "address" | "address.city" | "address.zip"
+ */
+export type DeepKeys<T, TDepth extends any[] = []> = TDepth["length"] extends 5 ? never : unknown extends T ? string : T extends readonly any[] & IsTuple<T> ? AllowedIndexes<T> | DeepKeysPrefix<T, AllowedIndexes<T>, TDepth> : T extends any[] ? DeepKeys<T[number], [...TDepth, any]> : T extends Date ? never : T extends object ? (keyof T & string) | DeepKeysPrefix<T, keyof T, TDepth> : never;
+export {};

package/dist/types/src/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './color';
+export * from './common';
+export * from './deep-keys';

package/dist/types/src/utils/chrono.d.ts

@@ -0,0 +1,152 @@
+import { DurationUnitType } from 'dayjs/plugin/duration';
+import { MaybeNull } from '../types';
+import { default as dayjs } from 'dayjs';
+export type Dayjs = dayjs.Dayjs;
+/**
+ * Temporal picker mode type.
+ * Defines the granularity of date/time selection.
+ */
+export type TemporalMode = "minute" | "hour" | "time" | "date" | "datetime" | "week" | "month" | "quarter" | "year";
+export declare const DEFAULT_DATE_FORMAT = "YYYY-MM-DD";
+export declare const DEFAULT_TIME_FORMAT = "HH:mm:ss";
+export declare const DEFAULT_DATETIME_FORMAT = "YYYY-MM-DD HH:mm:ss";
+export declare const LOCALIZED_DATETIME_FORMAT = "LLLL";
+export declare const LOCALIZED_DATE_FORMAT = "LLdddd";
+/**
+ * Format duration to human readable string.
+ *
+ * @param value - Duration value
+ * @param unit - The unit of the duration (default: "seconds")
+ * @returns Formatted duration string
+ * @example
+ * ```ts
+ * formatDuration(60) // "1分钟"
+ * formatDuration(3600) // "1小时0分钟"
+ * formatDuration(86400) // "1天0小时0分钟"
+ * formatDuration(90061) // "1天1小时1分钟"
+ * ```
+ */
+export declare function formatDuration(value: number, unit?: DurationUnitType): string;
+/**
+ * Parses a date string into a dayjs instance with optional format.
+ *
+ * @param date - The date string or Date object to parse
+ * @param format - The format string to use for parsing (optional, ignored for Date objects)
+ * @returns A dayjs instance
+ * @example
+ * ```ts
+ * parseDate("2025-11-10") // dayjs instance
+ * parseDate("2025-11-10 16:30:45") // dayjs instance
+ * parseDate("20251110", "YYYYMMDD") // dayjs instance with custom format
+ * parseDate("10/11/2025", "DD/MM/YYYY") // dayjs instance with custom format
+ * parseDate(new Date()) // dayjs instance from Date object
+ * ```
+ */
+export declare function parseDate(date: string | Date, format?: MaybeNull<string>): Dayjs;
+/**
+ * Attempts to parse a date string by trying various datetime and date formats.
+ * Returns null if parsing fails with all formats.
+ *
+ * @param date - The date string to parse
+ * @returns A dayjs instance if parsing succeeds, null otherwise
+ * @example
+ * ```ts
+ * tryParseDate("2025-11-10 16:30:45") // dayjs instance
+ * tryParseDate("2025/11/10") // dayjs instance
+ * tryParseDate("20251110") // dayjs instance
+ * tryParseDate("invalid date") // null
+ * ```
+ */
+export declare function tryParseDate(date: string): MaybeNull<Dayjs>;
+/**
+ * Formats a dayjs instance with the specified format.
+ *
+ * @param date - The dayjs instance to format
+ * @param format - The format string (defaults to "YYYY-MM-DD HH:mm:ss")
+ * @returns The formatted date string
+ * @example
+ * ```ts
+ * formatDate(dayjs()) // "2025-11-10 16:30:45"
+ * formatDate(dayjs(), "YYYY-MM-DD") // "2025-11-10"
+ * formatDate(dayjs(), "HH:mm:ss") // "16:30:45"
+ * ```
+ */
+export declare function formatDate(date: Dayjs, format?: string): string;
+/**
+ * Gets the current time as a dayjs instance.
+ *
+ * @returns The current time as a dayjs instance
+ * @example
+ * ```ts
+ * const now = getNow() // dayjs instance
+ * now.format("YYYY-MM-DD") // "2025-11-10"
+ * ```
+ */
+export declare function getNow(): Dayjs;
+/**
+ * Gets the current date string in "YYYY-MM-DD" format.
+ *
+ * @returns The current date string
+ * @example
+ * ```ts
+ * getNowDateString() // "2025-11-10"
+ * ```
+ */
+export declare function getNowDateString(): string;
+/**
+ * Gets the current time string in "HH:mm:ss" format.
+ *
+ * @returns The current time string
+ * @example
+ * ```ts
+ * getNowTimeString() // "16:30:45"
+ * ```
+ */
+export declare function getNowTimeString(): string;
+/**
+ * Gets the current date time string in "YYYY-MM-DD HH:mm:ss" format.
+ *
+ * @returns The current date time string
+ * @example
+ * ```ts
+ * getNowDateTimeString() // "2025-11-10 16:30:45"
+ * ```
+ */
+export declare function getNowDateTimeString(): string;
+/**
+ * Gets the current date time in a localized full format.
+ *
+ * @returns The localized date time string
+ * @example
+ * ```ts
+ * // With zh-cn locale
+ * getLocalizedDateTime() // "2025年11月10日星期日下午4点30分45秒"
+ * getLocalizedDateTime(false) // "2025年11月10日星期日"
+ * ```
+ */
+export declare function getLocalizedDateTime(includeTime?: boolean): string;
+declare const FORMAT_MAP: {
+    readonly year: readonly ["YYYY"];
+    readonly quarter: readonly ["YYYY-Q季度"];
+    readonly month: readonly ["YYYY-MM", "YYYY/MM", "YYYY.MM", "YYYYMM"];
+    readonly week: readonly ["YYYY-wo"];
+    readonly date: readonly ["YYYY-MM-DD", "YYYY/MM/DD", "YYYY.MM.DD", "YYYYMMDD", "YY/MM/DD", "YY.MM.DD", "YYMMDD"];
+    readonly time: readonly ["HH:mm:ss", "HH.mm.ss", "HHmmss"];
+    readonly hour: readonly ["HH"];
+    readonly minute: readonly ["HH:mm", "HH.mm", "HHmm"];
+    readonly datetime: readonly ["YYYY-MM-DD HH:mm:ss", "YYYY/MM/DD HH:mm:ss", "YYYY.MM.DD HH.mm.ss", "YYYYMMDDHHmmss", "YY/MM/DD HH:mm:ss", "YY.MM.DD HH:mm:ss", "YY.MM.DD HH.mm.ss", "YYMMDDHHmmss"];
+};
+/**
+ * Gets the available format patterns for a temporal picker mode.
+ *
+ * @param mode - The temporal picker mode
+ * @returns An array of format strings for the specified mode
+ * @example
+ * ```ts
+ * getTemporalFormats("date") // ["YYYY-MM-DD", "YYYY/MM/DD", ...]
+ * getTemporalFormats("time") // ["HH:mm:ss", "HH.mm.ss", "HHmmss"]
+ * getTemporalFormats("datetime") // ["YYYY-MM-DD HH:mm:ss", ...]
+ * ```
+ */
+export declare function getTemporalFormats<const T extends TemporalMode>(mode: T): typeof FORMAT_MAP[T];
+export {};

package/dist/types/src/utils/equal.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shallowly compares two values.
+ *
+ * @param value1 - The first value to compare.
+ * @param value2 - The second value to compare.
+ * @returns `true` if the values are shallowly equal, `false` otherwise.
+ */
+export declare function isShallowEqual(value1: unknown, value2: unknown): boolean;
+/**
+ * Deeply compares two values, with support for circular references.
+ *
+ * @param value1 - The first value to compare.
+ * @param value2 - The second value to compare.
+ * @returns `true` if the values are deeply equal, `false` otherwise.
+ */
+export declare function isDeepEqual(value1: unknown, value2: unknown): boolean;

package/dist/types/src/utils/error.d.ts

@@ -0,0 +1,22 @@
+import * as stackTrace from "stacktrace-js";
+export type StackFrame = stackTrace.StackFrame;
+/**
+ * Parse error stack and optionally filter frames.
+ */
+export declare function parseErrorStack(error: Error, filter?: (frame: StackFrame) => boolean): Promise<StackFrame[]>;
+/**
+ * Filter to exclude node_modules frames (user code only).
+ */
+export declare function filterUserFrame(stackFrame: StackFrame): boolean;
+/**
+ * Get sanitized error stack with user frames only.
+ */
+export declare function getSanitizedErrorStack(error: Error): Promise<string>;
+/**
+ * Get current call stack.
+ */
+export declare function getCurrentStack(filter?: (frame: StackFrame) => boolean): Promise<StackFrame[]>;
+/**
+ * Get current call stack synchronously.
+ */
+export declare function getCurrentStackSync(filter?: (frame: StackFrame) => boolean): StackFrame[];

package/dist/types/src/utils/event.d.ts

@@ -0,0 +1,46 @@
+import { EventHandlerMap, EventType, Handler } from 'mitt';
+/**
+ * Type-safe event emitter wrapper around mitt library.
+ */
+export declare class EventEmitter<TEvents extends Record<EventType, any> = Record<EventType, unknown>> {
+    #private;
+    /**
+     * Subscribe to an event. Returns unsubscribe function.
+     */
+    on<const TEventType extends keyof TEvents>(eventType: TEventType, eventListener: Handler<TEvents[TEventType]>): () => void;
+    /**
+     * Emit an event with optional payload.
+     */
+    emit<const TEventType extends keyof TEvents>(eventType: undefined extends TEvents[TEventType] ? TEventType : never): void;
+    emit<const TEventType extends keyof TEvents>(eventType: TEventType, eventPayload: TEvents[TEventType]): void;
+    /**
+     * Remove listener(s) for an event type.
+     */
+    off<const TEventType extends keyof TEvents>(eventType: TEventType, eventListener?: Handler<TEvents[TEventType]>): void;
+    /**
+     * Remove all listeners from all events.
+     */
+    clear(): void;
+    /**
+     * Get all registered listeners (for debugging).
+     */
+    getAllListeners(): EventHandlerMap<TEvents>;
+}
+/**
+ * Create a new EventEmitter instance.
+ *
+ * @example
+ * ```typescript
+ * interface AppEvents {
+ *   'user:login': { userId: string };
+ *   'user:logout': void;
+ * }
+ *
+ * const emitter = createEventEmitter<AppEvents>();
+ * const unsubscribe = emitter.on('user:login', ({ userId }) => {
+ *   console.log(`User ${userId} logged in`);
+ * });
+ * ```
+ */
+export declare function createEventEmitter<TEvents extends Record<EventType, any> = Record<EventType, unknown>>(): EventEmitter<TEvents>;
+export { type Handler as EventHandler, type EventType } from 'mitt';

package/dist/types/src/utils/format.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Format bytes to human readable string
+ *
+ * @param bytes - Number of bytes
+ * @param decimals - Number of decimal places (default: 2)
+ * @returns Formatted string with unit (B, KB, MB, GB, TB, PB)
+ * @example
+ * ```ts
+ * formatBytes(1024) // "1 KB"
+ * formatBytes(1536, 1) // "1.5 KB"
+ * formatBytes(1048576) // "1 MB"
+ * formatBytes(0) // "0 B"
+ * ```
+ */
+export declare function formatBytes(bytes: number, decimals?: number): string;
+/**
+ * Format large numbers to human readable string with units (K, M, B, T)
+ *
+ * @param num - Number to format
+ * @param decimals - Number of decimal places (default: 2)
+ * @returns Formatted string with unit (K, M, B, T)
+ * @example
+ * ```ts
+ * formatNumber(1000) // "1 K"
+ * formatNumber(1500, 1) // "1.5 K"
+ * formatNumber(1234567) // "1.23 M"
+ * formatNumber(999) // "999"
+ * formatNumber(0) // "0"
+ * ```
+ */
+export declare function formatNumber(num: number, decimals?: number): string;

package/dist/types/src/utils/function.d.ts

@@ -0,0 +1,27 @@
+import { Awaitable, MaybeUndefined } from '../types';
+export interface AwaitableFnInvocationOptions<in TResult, in out TContext = unknown> {
+    onInvoke?: () => MaybeUndefined<TContext>;
+    onSuccess?: (result: TResult, context: MaybeUndefined<TContext>) => void;
+    onError?: (error: unknown, context: MaybeUndefined<TContext>) => void;
+    onFinally?: (context: MaybeUndefined<TContext>) => void;
+}
+/**
+ * Checks if a function is an async function.
+ */
+export declare function isAsyncFunction(fn: Function): fn is (...args: any[]) => Promise<any>;
+/**
+ * Invokes an awaitable function with lifecycle hooks.
+ */
+export declare function invokeAwaitableFn<TArgs extends any[] = any[], TResult = unknown, TContext = unknown>(fn: (...args: TArgs) => Awaitable<TResult>, args: NoInfer<TArgs>, options: AwaitableFnInvocationOptions<NoInfer<TResult>, TContext>): Promise<TResult>;
+/**
+ * Returns the value itself (identity function).
+ */
+export declare function identity<T>(value: T): T;
+/**
+ * Creates a function that throws a not-implemented error.
+ */
+export declare function createThrowNotImplementedFn(feature?: string): () => never;
+/**
+ * Throws a not-implemented error.
+ */
+export declare function throwNotImplemented(feature?: string): never;

package/dist/types/src/utils/id.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generates a unique ID based on browser fingerprint.
+ *
+ * @returns A unique ID string
+ */
+export declare function generateId(): string;

package/dist/types/src/utils/index.d.ts

@@ -0,0 +1,18 @@
+export * from './chrono';
+export * from './equal';
+export * from './error';
+export * from './event';
+export * from './format';
+export * from './function';
+export * from './id';
+export * from './key';
+export * from './lib';
+export * from './object';
+export * from './path';
+export * from './pinyin';
+export * from './security';
+export * from './string';
+export * from './table';
+export * from './task';
+export * from './tree';
+export * from './zod';

package/dist/types/src/utils/key.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generate a stable hash key from any value by serializing to JSON.
+ * Objects are normalized with sorted keys for consistent hashing.
+ */
+export declare function hashKey(key: unknown): string;

package/dist/types/src/utils/lib.d.ts

@@ -0,0 +1,5 @@
+export declare const alwaysTrue: () => boolean;
+export declare const alwaysFalse: () => boolean;
+export { klona as cloneDeep } from 'klona';
+export { parse as decodeQueryString, stringify as encodeQueryString } from 'qs';
+export { always, assign, camel as camelCase, capitalize, cluster, debounce, first, get, isArray, isBigInt, isBoolean, isDate, isEmpty, isError, isFloat, isFunction, isInt, isIntString, isMap, isNullish, isNumber, isObject, isPlainObject, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isUndefined, isWeakMap, isWeakSet, dash as kebabCase, last, max, memo as memoize, min, noop, omit, once, pascal as pascalCase, pick, set, similarity, snake as snakeCase, sum, template, throttle, toFloat, toInt, trim, unique } from 'radashi';

package/dist/types/src/utils/object.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Merges the source object into the target object
+ *
+ * @param target - The target object
+ * @param source - The source object
+ * @param overrideExisting - Whether to override existing values
+ * @returns The merged object with the source object merged into the target object
+ */
+export declare function mergeWith<T extends object>(target: T, source: Partial<T>, overrideExisting?: boolean): T;

package/dist/types/src/utils/path.d.ts

@@ -0,0 +1,13 @@
+import { default as path } from 'path-browserify';
+export type PathObject = path.PathObject;
+export declare function getBaseName(filePath: string, keepExt?: boolean): string;
+export declare function getExtName(filePath: string): string;
+export declare function getDirName(filePath: string): string;
+export declare function joinPaths(...paths: string[]): string;
+export declare function isAbsolutePath(filePath: string): boolean;
+export declare function normalizePath(filePath: string): string;
+export declare function parsePath(filePath: string): PathObject;
+export declare function formatPath(pathObject: PathObject): string;
+export declare function getRelativePath(from: string, to: string): string;
+export declare function resolvePath(...pathSegments: string[]): string;
+export declare const pathSeparator: string;

package/dist/types/src/utils/pinyin.d.ts

@@ -0,0 +1,40 @@
+import { AnyObject, If, IsOptionalKeyOf, IsRequiredKeyOf, IsString, Simplify } from '../types';
+export type WithPinyin<T extends AnyObject, K extends keyof T & string> = Simplify<WithPinyinInternal<T, K>>;
+type WithPinyinInternal<T extends AnyObject, K extends keyof T & string> = T & {
+    [Key in K as If<IsRequiredKeyOf<T, Key>, If<IsString<T[Key]>, `${Key}Pinyin`, never>, never>]: string;
+} & {
+    [Key in K as If<IsRequiredKeyOf<T, Key>, If<IsString<T[Key]>, `${Key}PinyinInitials`, never>, never>]: string;
+} & {
+    [Key in K as If<IsOptionalKeyOf<T, Key>, If<IsString<T[Key]>, `${Key}Pinyin`, never>, never>]?: string;
+} & {
+    [Key in K as If<IsOptionalKeyOf<T, Key>, If<IsString<T[Key]>, `${Key}PinyinInitials`, never>, never>]?: string;
+};
+/**
+ * Get the pinyin representation of Chinese text
+ *
+ * @param text - The Chinese text to convert
+ * @returns Array of pinyin strings for each character
+ */
+export declare function getPinyin(text: string): string[];
+/**
+ * Get the initial letters (first letters) of pinyin for Chinese text
+ *
+ * @param text - The Chinese text to convert
+ * @returns Array of initial letters for each character
+ */
+export declare function getPinyinInitials(text: string): string[];
+/**
+ * Add pinyin fields to an object for specified string keys
+ *
+ * @param obj - The source object
+ * @param keys - The keys to add pinyin fields for
+ * @returns A new object with additional pinyin and pinyin initials fields
+ * @example
+ * ```ts
+ * const user = { name: "张三", age: 25 };
+ * const result = withPinyin(user, "name");
+ * // result: { name: "张三", age: 25, namePinyin: "zhangsan", namePinyinInitials: "zs" }
+ * ```
+ */
+export declare function withPinyin<T extends AnyObject, K extends keyof T & string>(obj: T, ...keys: K[]): WithPinyin<T, K>;
+export {};

package/dist/types/src/utils/security.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Encode a string to XOR-encrypted byte array.
+ *
+ * @param plainText The plain text string to encode
+ * @returns The encrypted byte array
+ */
+export declare function obfuscateEncode(plainText: string): Uint8Array;
+/**
+ * Decode an XOR-encrypted byte array to string.
+ *
+ * @param encoded The encrypted byte array
+ * @returns The decoded string
+ */
+export declare function obfuscateDecode(encoded: Uint8Array | number[]): string;
+/**
+ * Encode a string to XOR-encrypted hex string.
+ *
+ * @param plainText The plain text string to encode
+ * @returns The encrypted hex string
+ */
+export declare function obfuscateEncodeToHex(plainText: string): string;
+/**
+ * Decode an XOR-encrypted hex string to plain text.
+ *
+ * @param hexString The encrypted hex string
+ * @returns The decoded string
+ */
+export declare function obfuscateDecodeFromHex(hexString: string): string;
+/**
+ * Encode a string to XOR-encrypted base64 string.
+ *
+ * @param plainText The plain text string to encode
+ * @returns The encrypted base64 string
+ */
+export declare function obfuscateEncodeToBase64(plainText: string): string;
+/**
+ * Decode an XOR-encrypted base64 string to plain text.
+ *
+ * @param base64String The encrypted base64 string
+ * @returns The decoded string
+ */
+export declare function obfuscateDecodeFromBase64(base64String: string): string;
+/**
+ * Encrypts a given value using RSA encryption with the given public key.
+ *
+ * @param value The value to encrypt
+ * @param publicKey The public key to use for encryption
+ * @returns The encrypted value
+ * @throws If the encryption fails or inputs are invalid
+ */
+export declare function encryptUsingRSA(value: string, publicKey: string): string;
+/**
+ * Decrypts a given value using RSA encryption with the given private key.
+ *
+ * @param value The value to decrypt
+ * @param privateKey The private key to use for decryption
+ * @returns The decrypted value
+ * @throws If the decryption fails or inputs are invalid
+ */
+export declare function decryptUsingRSA(value: string, privateKey: string): string;

package/dist/types/src/utils/string.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Convert a string to constant case
+ *
+ * @param value - The value
+ * @returns - The constant case string
+ */
+export declare function constantCase(value: string): string;
+/**
+ * Convert an unknown value to string
+ *
+ * @param value - The value to stringify
+ * @param emptyForNullish - Whether to return empty string for null/undefined (default: true)
+ * @returns - The string representation
+ */
+export declare function stringify(value: unknown): string;

package/dist/types/src/utils/table.d.ts

@@ -0,0 +1,25 @@
+import { AnyObject } from '../types';
+/**
+ * Comparison mode for reference values
+ */
+export type CompareMode = "reference" | "shallow" | "deep";
+/**
+ * Options for shouldUpdateByKeys
+ */
+export interface ShouldUpdateByKeysOptions {
+    /**
+     * Comparison mode for reference values
+     * - "reference": Use strict equality (===)
+     * - "shallow": Use shallow comparison
+     * - "deep": Use deep comparison
+     *
+     * @default "reference"
+     */
+    compare?: CompareMode;
+}
+/**
+ * Creates a function that checks if any specified keys differ between two objects.
+ * Useful for Table's shouldCellUpdate prop to optimize re-renders.
+ */
+export declare function shouldUpdateByKeys<T = AnyObject, const K extends keyof T = keyof T>(options: ShouldUpdateByKeysOptions, ...keys: K[]): (next: T, prev: T) => boolean;
+export declare function shouldUpdateByKeys<T = AnyObject, const K extends keyof T = keyof T>(...keys: K[]): (next: T, prev: T) => boolean;

package/dist/types/src/utils/task.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Schedule a microtask with fallback for older environments.
+ */
+export declare function scheduleMicrotask(task: () => void): void;