@unicom-cloud/utils 0.1.23 → 0.1.25

package/types/snapdom/src/modules/fonts.d.ts

@@ -7,21 +7,77 @@
  * @param {string|number} fontWeight - The font weight
  * @param {number} [fontSize=32] - The font size in pixels
  * @param {string} [color="#000"] - The color to use
- * @returns {Promise<string>} Data URL of the rendered icon
+ * @returns {Promise<{dataUrl:string,width:number,height:number}>} Data URL and intrinsic size
  */
-export function iconToImage(unicodeChar: string, fontFamily: string, fontWeight: string | number, fontSize?: number, color?: string): Promise<string>;
+export function iconToImage(unicodeChar: string, fontFamily: string, fontWeight: string | number, fontSize?: number, color?: string): Promise<{
+    dataUrl: string;
+    width: number;
+    height: number;
+}>;
 /**
- * Embeds custom fonts found in the document as data URLs in CSS.
+ * Embed only the @font-face rules that match required variants AND intersect used unicode ranges.
+ * Smart by default + simple "exclude" knobs (no regex for end users).
+ *
+ * @typedef {{family:string, weightSpec:string, styleSpec:string, stretchSpec:string, unicodeRange:string, srcRaw:string, srcUrls:string[], href:string}} FontFaceMeta
  *
- * @export
  * @param {Object} options
- * @param {boolean} [options.preCached=false] - Whether to use pre-cached resources
- * @param {Object} [options.localFonts=[]] - Additional local fonts to embed
- * @param {string} [options.useProxy=''] - Optional proxy for font fetching
- * @returns {Promise<string>} The inlined CSS for custom fonts
+ * @param {Set<string>} options.required                     // keys: "family__weight__style__stretchPct"
+ * @param {Set<number>} options.usedCodepoints               // codepoints used in the captured subtree
+ * @param {{families?:string[], domains?:string[], subsets?:string[]}} [options.exclude] // simple exclude
+ * @param {Array<{family:string,src:string,weight?:string|number,style?:string,stretchPct?:number}>} [options.localFonts=[]]
+ * @param {string}  [options.useProxy=""]
+ * @returns {Promise<string>} inlined @font-face CSS
  */
-export function embedCustomFonts({ preCached, localFonts, useProxy, }?: {
-    preCached?: boolean | undefined;
-    localFonts?: Object | undefined;
+export function embedCustomFonts({ required, usedCodepoints, exclude, localFonts, useProxy, }?: {
+    required: Set<string>;
+    usedCodepoints: Set<number>;
+    exclude?: {
+        families?: string[];
+        domains?: string[];
+        subsets?: string[];
+    } | undefined;
+    localFonts?: {
+        family: string;
+        src: string;
+        weight?: string | number;
+        style?: string;
+        stretchPct?: number;
+    }[] | undefined;
     useProxy?: string | undefined;
 }): Promise<string>;
+/**
+ * Collects used font variants (family, weight, style, stretch) in subtree.
+ * @param {Element} root
+ * @returns {Set<string>} keys "family__weight__style__stretchPct"
+ */
+export function collectUsedFontVariants(root: Element): Set<string>;
+/**
+ * Collects used codepoints in subtree (including ::before/::after content).
+ * @param {Element} root
+ * @returns {Set<number>}
+ */
+export function collectUsedCodepoints(root: Element): Set<number>;
+/**
+ * Ensures web fonts are fully resolved before capture, with a Safari-friendly warm-up.
+ * - Awaits document.fonts.ready
+ * - Forces layout/rasterization for each family by painting hidden spans
+ * - Optionally retries a couple of times if Safari is still lazy
+ *
+ * @param {Set<string>|string[]} families - Plain family names (e.g., "Mansalva", "Unbounded")
+ * @param {number} [warmupRepetitions=2] - How many times to warm-up each family
+ * @returns {Promise<void>}
+ */
+export function ensureFontsReady(families: Set<string> | string[], warmupRepetitions?: number): Promise<void>;
+/**
+ * Embed only the
+ */
+export type FontFaceMeta = {
+    family: string;
+    weightSpec: string;
+    styleSpec: string;
+    stretchSpec: string;
+    unicodeRange: string;
+    srcRaw: string;
+    srcUrls: string[];
+    href: string;
+};

package/types/snapdom/src/modules/iconFonts.d.ts

@@ -1,2 +1,36 @@
 export function extendIconFonts(fonts: any): void;
 export function isIconFont(input: any): boolean;
+/**
+ * Rasterization helpers for Google Material Icons / Material Symbols that use ligatures.
+ * Converts elements that render icons via text ligatures into inline <img> (data URL).
+ * This runs on the CLONE tree (never mutates the original).
+ *
+ * @module materialIcons
+ */
+/** True si la familia es Material Icons / Material Symbols */
+export function isMaterialFamily(family?: string): boolean;
+/** Espera a que la fuente esté lista (ligaduras) */
+export function ensureMaterialFontsReady(family?: string, px?: number): Promise<void>;
+/**
+ * Dibuja la ligadura (ej. "face") en canvas → dataURL PNG.
+ */
+export function materialIconToImage(ligatureText: any, { family, weight, fontSize, color, variation, }?: {
+    family?: string | undefined;
+    weight?: string | undefined;
+    fontSize?: number | undefined;
+    color?: string | undefined;
+    variation?: string | undefined;
+}): Promise<{
+    dataUrl: string;
+    width: number;
+    height: number;
+}>;
+/**
+ * Reemplaza nodos de Material (ligaduras) por <img> en el CLONE.
+ * IMPORTANTE: leé estilos del SOURCE para obtener el color correcto.
+ *
+ * @param {Element} cloneRoot - subárbol clonado
+ * @param {Element} sourceRoot - subárbol original (para estilos reales)
+ * @returns {Promise<number>}
+ */
+export function ligatureIconToImage(cloneRoot: Element, sourceRoot: Element): Promise<number>;

package/types/snapdom/src/modules/images.d.ts

@@ -1,8 +1,14 @@
 /**
- * Converts all <img> elements in the clone to data URLs or replaces them with placeholders if loading fails.
+ * Converts all <img> elements in the clone to data URLs or replaces them with
+ * placeholders if loading fails. Compatible with the new non-throwing snapFetch.
+ *
+ * - Success: result.ok === true && typeof result.data === 'string' (DataURL)
+ * - Failure: any other case → replace <img> with a sized fallback <div>
  *
  * @param {Element} clone - Clone of the original element
- * @param {Object} [options={}] - Options for image processing
- * @returns {Promise<void>} Promise that resolves when all images are processed
+ * @param {{ useProxy?: string }} [options={}] - Options for image processing
+ * @returns {Promise<void>}
  */
-export function inlineImages(clone: Element, options?: Object): Promise<void>;
+export function inlineImages(clone: Element, options?: {
+    useProxy?: string;
+}): Promise<void>;

package/types/snapdom/src/modules/lineClamp.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Apply a multi-line ellipsis ONLY if the target element declares
+ * -webkit-line-clamp/line-clamp. Uses the real layout (scrollHeight) and
+ * mutates the ORIGINAL node briefly (binary search on text + '…'),
+ * then returns an undo() that restores everything right after cloning.
+ *
+ * Scope intentionally minimal: ROOT element only, plain text container
+ * (like your demo). This mirrors the working snippet exactly.
+ *
+ * @param {Element} el
+ * @returns {() => void} undo function (no-op if nothing changed)
+ */
+export function lineClamp(el: Element): () => void;

package/types/snapdom/src/modules/pseudo.d.ts

@@ -3,8 +3,8 @@
  *
  * @param {Element} source - Original element
  * @param {Element} clone - Cloned element
- * @param {boolean} compress - Whether to compress style keys
- * @param {boolean} embedFonts - Whether to embed icon fonts as images
- * @returns {Promise} Promise that resolves when all pseudo-elements are processed
+ * @param {Map} sessionCache - styleMap cache etc.
+ * @param {Object} options - capture options
+ * @returns {Promise<void>}
  */
-export function inlinePseudoElements(source: Element, clone: Element, styleMap: any, styleCache: any, options: any): Promise<any>;
+export function inlinePseudoElements(source: Element, clone: Element, sessionCache: Map<any, any>, options: Object): Promise<void>;

package/types/snapdom/src/modules/rasterize.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Converts to an HTMLImageElement with raster format.
+ * @param {string} url - Image data URL.
+ * @param {object} options - Context including format and dpr.
+ * @param {string} options.format - Output format ('png', 'jpeg', 'webp').
+ * @param {number} options.dpr - Device pixel ratio.
+ * @param {number} [options.quality] - Image quality for lossy formats.
+ * @param {string} [options.backgroundColor] - Optional background color.
+ * @returns {Promise<HTMLImageElement>} Resolves with the rasterized Image element.
+ */
+export function rasterize(url: string, options: {
+    format: string;
+    dpr: number;
+    quality?: number | undefined;
+    backgroundColor?: string | undefined;
+}): Promise<HTMLImageElement>;

package/types/snapdom/src/modules/snapFetch.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Unified, non-throwing fetch with minimal, deduplicated logging.
+ * @param {string} url
+ * @param {SnapFetchOptions} [options]
+ * @returns {Promise<SnapFetchResult>}
+ */
+export function snapFetch(url: string, options?: SnapFetchOptions): Promise<SnapFetchResult>;
+/**
+ * snapFetch — unified fetch for SnapDOM
+ * - Single inflight queue & error cache (with TTL)
+ * - Timeout via AbortController
+ * - Optional proxy handling ("...{url}" or "...?url=")
+ * - Non-throwing: always resolves { ok, data|null, status, url, reason, ... }
+ * - Thin, deduplicated logging: `[snapDOM]` warn/error with TTL + session cap
+ */
+export type FetchAs = "text" | "blob" | "dataURL";
+/**
+ * snapFetch — unified fetch for SnapDOM
+ * - Single inflight queue & error cache (with TTL)
+ * - Timeout via AbortController
+ * - Optional proxy handling ("...{url}" or "...?url=")
+ * - Non-throwing: always resolves { ok, data|null, status, url, reason, ... }
+ * - Thin, deduplicated logging: `[snapDOM]` warn/error with TTL + session cap
+ */
+export type SnapFetchOptions = {
+    /**
+     * Expected result type.
+     */
+    as?: FetchAs | undefined;
+    /**
+     * Timeout in ms.
+     */
+    timeout?: number | undefined;
+    /**
+     * Proxy template or base URL. Supports "{url}" or "?url=" patterns.
+     */
+    useProxy?: string | undefined;
+    /**
+     * ms to cache errors to avoid retry storms.
+     */
+    errorTTL?: number | undefined;
+    /**
+     * Override inferred credentials.
+     */
+    credentials?: RequestCredentials | undefined;
+    /**
+     * Optional headers.
+     */
+    headers?: Record<string, string> | undefined;
+    /**
+     * If true, disables console logging for this call.
+     */
+    silent?: boolean | undefined;
+    /**
+     * Optional hook when a fetch fails (ok=false).
+     */
+    onError?: ((r: SnapFetchResult) => void) | undefined;
+};
+/**
+ * snapFetch — unified fetch for SnapDOM
+ * - Single inflight queue & error cache (with TTL)
+ * - Timeout via AbortController
+ * - Optional proxy handling ("...{url}" or "...?url=")
+ * - Non-throwing: always resolves { ok, data|null, status, url, reason, ... }
+ * - Thin, deduplicated logging: `[snapDOM]` warn/error with TTL + session cap
+ */
+export type SnapFetchResult = {
+    ok: boolean;
+    /**
+     * Text, Blob, or DataURL (depending on `as`).
+     */
+    data: string | Blob | null;
+    /**
+     * HTTP status (0 on network/timeout).
+     */
+    status: number;
+    /**
+     * Final URL (after proxy if applied).
+     */
+    url: string;
+    /**
+     * Served from inflight/error cache.
+     */
+    fromCache: boolean;
+    /**
+     * Best-effort MIME (blob/dataURL modes).
+     */
+    mime?: string | undefined;
+    /**
+     * Failure reason (e.g., 'http_error','timeout','abort','network').
+     */
+    reason?: string | undefined;
+};

package/types/snapdom/src/modules/styles.d.ts

@@ -1 +1,2 @@
-export function inlineAllStyles(source: any, clone: any, styleMap: any, cache: any, compress: any): void;
+export function notifyStyleEpoch(): void;
+export function inlineAllStyles(source: any, clone: any, sessionOrCtx: any, opts: any): Promise<void>;

package/types/snapdom/src/modules/svgDefs.d.ts

@@ -1,19 +1,13 @@
 /**
- * Ensures that all external <symbol> or <defs> elements referenced by <use>
- * inside the given root element are inlined into it.
+ * Inline external <defs> and <symbol> dependencies needed by an SVG subtree (or multiple SVGs),
+ * so that serialization does not break. Handles:
+ *  1) <use href="#..."> targets (symbols/defs)
+ *  2) Attributes/inline styles that reference url(#id) (gradients, patterns, filters, clipPath, mask, marker-*)
+ *  3) Recursive chains via href/xlink:href and nested url(#...) inside cloned defs
  *
- * This is necessary when capturing or exporting an SVG fragment that relies on
- * definitions existing elsewhere in the document, ensuring it remains
- * self-contained and renders correctly.
+ * Fast path: no computed styles, no layout reads. Only DOM queries + cloning.
  *
- * Process:
- * 1. Collect all IDs referenced by <use> elements in the root.
- * 2. Look up those IDs in the global document (outside the root).
- * 3. Create or reuse a hidden <svg> container inside the root to hold inlined defs.
- * 4. Only insert missing <symbol>/<defs> elements that are not already present.
- *
- * Existing definitions in the root are never modified or removed.
- *
- * @param {HTMLElement} rootElement - The root element being processed (typically the cloned DOM fragment).
+ * @param {Element} element - SVG root or container holding one/more SVGs.
+ * @param {Document|ParentNode} [lookupRoot] - Where to search for external defs/symbols (defaults to element.ownerDocument).
  */
-export function inlineExternalDefsAndSymbols(rootElement: HTMLElement): void;
+export function inlineExternalDefsAndSymbols(element: Element, lookupRoot?: Document | ParentNode): void;

package/types/snapdom/src/utils/browser.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates a promise that resolves after the specified delay
+ * @param {number} [ms=0] - Milliseconds to delay
+ * @returns {Promise<void>} Promise that resolves after the delay
+ */
+export function idle(fn: any, { fast }?: {
+    fast?: boolean | undefined;
+}): Promise<void>;
+/**
+ * Detecta Safari real + Safari en iOS WebView (UIWebView/WKWebView) + variantes WeChat.
+ */
+export function isSafari(): boolean;

package/types/snapdom/src/utils/css.d.ts

@@ -0,0 +1,68 @@
+export function precacheCommonTags(): void;
+export function getDefaultStyleForTag(tagName: any): any;
+/**
+ * Returns true if a CSS property should be ignored because it does not affect
+ * the static pixel output of a frame capture.
+ * - Matches prefixes (fast path) and tokens (e.g., “...-animation-...”).
+ * - Skips a curated set of exact property names.
+ * @param {string} prop
+ * @returns {boolean}
+ */
+export function shouldIgnoreProp(prop: string): boolean;
+/**
+ * Builds a style key from a snapshot; returns "" for tags in NO_DEFAULTS_TAGS.
+ * @param {Record<string,string>} snapshot
+ * @param {string} tagName
+ */
+export function getStyleKey(snapshot: Record<string, string>, tagName: string): string;
+/**
+ * Collects all unique tag names used in the DOM tree rooted at the given node.
+ *
+ * @param {Node} root - The root node to search
+ * @returns {string[]} Array of unique tag names
+ */
+export function collectUsedTagNames(root: Node): string[];
+/**
+ * Generates deduplicated base CSS for the given tag names.
+ *
+ * @param {string[]} usedTagNames - Array of tag names
+ * @returns {string} CSS string
+ */
+export function generateDedupedBaseCSS(usedTagNames: string[]): string;
+/**
+ * Generates CSS classes from a style map.
+ *
+ * @returns {Map} Map of style keys to class names
+ */
+export function generateCSSClasses(styleMap: any): Map<any, any>;
+/**
+ * Gets the computed style for an element or pseudo-element, with caching.
+ *
+ * @param {Element} el - The element
+ * @param {string|null} [pseudo=null] - The pseudo-element
+ * @returns {CSSStyleDeclaration} The computed style
+ */
+export function getStyle(el: Element, pseudo?: string | null): CSSStyleDeclaration;
+/**
+ * Parses the CSS content property value, handling unicode escapes.
+ *
+ * @param {string} content - The CSS content value
+ * @returns {string} The parsed content
+ */
+export function parseContent(content: string): string;
+/**
+ * @export
+ * @param {CSSStyleDeclaration} style
+ * @return {Record<string,string>}
+ */
+export function snapshotComputedStyle(style: CSSStyleDeclaration): Record<string, string>;
+/**
+ * @export
+ * @param {string} bg
+ * @return {string[]}
+ */
+export function splitBackgroundImage(bg: string): string[];
+/** Tags that Snapdom must never capture (skip node + subtree). */
+export const NO_CAPTURE_TAGS: Set<string>;
+/** Tags that must not generate default styles nor auto-classes. */
+export const NO_DEFAULTS_TAGS: Set<string>;

package/types/snapdom/src/utils/helpers.d.ts

@@ -1,39 +1,3 @@
-/**
- * Fetches and inlines a single background-image entry to a data URL (with caching).
- * - If entry is a gradient or "none", returns unchanged.
- * - If entry is a url(...), fetches the image as data URL and caches it.
- *
- * @param {string} entry - Single background-image entry (e.g., "url(...)").
- * @param {Object} [options={}] - Options like crossOrigin.
- * @param {boolean} [options.skipInline=false] - If true, only fetches & caches, doesn't return a replacement.
- * @returns {Promise<string|void>} - The processed entry (unless skipInline is true).
- */
-export function inlineSingleBackgroundEntry(entry: string, options?: {
-    skipInline?: boolean | undefined;
-}): Promise<string | void>;
-/**
- * Creates a promise that resolves after the specified delay
- * @param {number} [ms=0] - Milliseconds to delay
- * @returns {Promise<void>} Promise that resolves after the delay
- */
-export function idle(fn: any, { fast }?: {
-    fast?: boolean | undefined;
-}): Promise<void>;
-/**
- * Gets the computed style for an element or pseudo-element, with caching.
- *
- * @param {Element} el - The element
- * @param {string|null} [pseudo=null] - The pseudo-element
- * @returns {CSSStyleDeclaration} The computed style
- */
-export function getStyle(el: Element, pseudo?: string | null): CSSStyleDeclaration;
-/**
- * Parses the CSS content property value, handling unicode escapes.
- *
- * @param {string} content - The CSS content value
- * @returns {string} The parsed content
- */
-export function parseContent(content: string): string;
 /**
  * Extracts a URL from a CSS value like background-image.
  *
@@ -48,30 +12,5 @@ export function extractURL(value: string): string | null;
  * @returns {boolean} True if it is an icon font
  */
 export function isIconFont(familyOrUrl: string): boolean;
-/**
- * Fetch a resource with optional proxy fallback.
- * @param {string} url - Resource URL
- * @param {Object} [options]
- * @param {string} [options.useProxy=''] - Proxy prefix
- * @returns {Promise<Response>} The fetched response
- */
-export function fetchResource(url: string, { useProxy }?: {
-    useProxy?: string | undefined;
-}): Promise<Response>;
-export function fetchImage(src: any, { timeout, useProxy, errorTTL }?: {
-    timeout?: number | undefined;
-    useProxy?: string | undefined;
-    errorTTL?: number | undefined;
-}): any;
-/**
- *
- *
- * @export
- * @param {*} style
- * @return {*}
- */
-export function snapshotComputedStyle(style: any): any;
-export function isSafari(): boolean;
 export function stripTranslate(transform: any): any;
 export function safeEncodeURI(uri: any): any;
-export function splitBackgroundImage(bg: any): any[];

package/types/snapdom/src/utils/image.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Adds a background color to the canvas if specified.
+ * @param {HTMLCanvasElement} baseCanvas - Source canvas element.
+ * @param {string} backgroundColor - CSS color string for the background.
+ * @returns {HTMLCanvasElement} Returns the original canvas if no background needed,
+ * or a new canvas with the background applied.
+ */
+export function createBackground(baseCanvas: HTMLCanvasElement, backgroundColor: string): HTMLCanvasElement;
+/**
+ * Inline a single background-image entry (one layer) robustly.
+ * - If it's a URL() and fetching fails, degrade to "none" instead of throwing.
+ * - Gradients and "none" are returned untouched.
+ * - Uses cache.background to avoid repeated work.
+ *
+ * @param {string} entry - A single background layer (e.g., 'url("...")', 'linear-gradient(...)', 'none')
+ * @param {{ useProxy?: string }} [options]
+ * @returns {Promise<string|undefined>} Inlined CSS value for this layer (e.g., `url("data:...")`), original entry, or "none".
+ */
+export function inlineSingleBackgroundEntry(entry: string, options?: {
+    useProxy?: string;
+}): Promise<string | undefined>;

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

@@ -0,0 +1,4 @@
+export { idle, isSafari } from "./browser.js";
+export { collectUsedTagNames, generateCSSClasses, generateDedupedBaseCSS, getDefaultStyleForTag, getStyle, getStyleKey, NO_CAPTURE_TAGS, NO_DEFAULTS_TAGS, parseContent, precacheCommonTags, snapshotComputedStyle, splitBackgroundImage } from "./css.js";
+export { extractURL, isIconFont, safeEncodeURI, stripTranslate } from "./helpers.js";
+export { createBackground, inlineSingleBackgroundEntry } from "./image.js";

package/types/tinycolor/src/public_api.d.ts

@@ -7,4 +7,4 @@ export * from './interfaces.js';
 export * from './random.js';
 export * from './readability.js';
 export * from './to-ms-filter.js';
-export * from './util.js';
+export * from './utils.js';

package/types/tree/index.d.ts

@@ -1,9 +1,9 @@
+export default getItemBy;
+export { default as searchTree } from "./search";
 export function findNodeBy(root: any, key: any, value: any, childrenKey?: string): any;
-export function getItemBy(root: any, key: any, value: any, childrenKey?: string): any;
-export function getItemBy3(root: any, key: any, value: any, childrenKey?: string): any;
-export function getItemByID(root: any, value: any): any;
-export function getLabelFromDictionaryByValue(a: any, value: any, 保底?: boolean): any;
 export function getChildWithParentBy(root: any, key: any, value: any, childrenKey?: string): null | undefined;
+export function getItemBy(root: any, key: any, value: any, childrenKey?: string, strict?: boolean): any;
 export function getItemBy2(root: any, key: any, value: any, childrenKey?: string): any;
-export default getItemBy;
-export { default as searchTree } from "./search";
+export function getItemByID(root: any, value: any): any;
+export function getLabelFromDictionaryByValue(a: any, value: any, 保底?: boolean): any;
+export { findNodeBy as getItemBy3 };

package/types/tween/index.d.ts

@@ -0,0 +1 @@
+export { default, easing, default as Tween } from "./src";

package/types/tween/src/easing.d.ts

@@ -0,0 +1,22 @@
+export function easeInBy(power: any): (t: any) => number;
+export function easeOutBy(power: any): (t: any) => number;
+export function easeInOutBy(power: any): (t: any) => number;
+export function linear(t: any): any;
+export function sineIn(t: any): number;
+export function sineOut(t: any): number;
+export function sineInOut(t: any): number;
+export function bounceOut(t: any): number;
+export function bounceIn(t: any): number;
+export function bounceInOut(t: any): number;
+export function quadIn(t: any): number;
+export function quadOut(t: any): number;
+export function quadInOut(t: any): number;
+export function cubicIn(t: any): number;
+export function cubicOut(t: any): number;
+export function cubicInOut(t: any): number;
+export function quartIn(t: any): number;
+export function quartOut(t: any): number;
+export function quartInOut(t: any): number;
+export function quintIn(t: any): number;
+export function quintOut(t: any): number;
+export function quintInOut(t: any): number;

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

@@ -0,0 +1,3 @@
+export { easing };
+export { default } from "./tween";
+import * as easing from './easing';

package/types/tween/src/tween.d.ts

@@ -0,0 +1,22 @@
+export default Tween;
+declare class Tween {
+    constructor(options: any);
+    from: any;
+    to: any;
+    duration: any;
+    delay: any;
+    easing: any;
+    onStart: any;
+    onUpdate: any;
+    onFinish: any;
+    startTime: any;
+    started: boolean;
+    finished: boolean;
+    timer: number | null;
+    keys: {};
+    update(): void;
+    time: number | undefined;
+    elapsed: any;
+    start(): void;
+    stop(): void;
+}

package/types/validate/index.d.ts

@@ -0,0 +1,3 @@
+export * from './src';
+export { default } from './src';
+export type * from './src';

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

@@ -0,0 +1,39 @@
+import type { GlobalConfig, InnerValidateOptions, SchemaType, ValidateMessagesType, ValidateOptions } from './interface';
+import enUSValidateLocale from './locale/en-US';
+import zhCNValidateLocale from './locale/zh-CN';
+import DefaultValidateMessage from './message';
+import ArrayValidator from './rules/array';
+import BooleanValidator from './rules/boolean';
+import CustomValidator from './rules/custom';
+import NumberValidator from './rules/number';
+import ObjectValidator from './rules/object';
+import StringValidator from './rules/string';
+import TypeValidator from './rules/type';
+import { mergeTemplate } from './utils';
+declare const PqbValidate: {
+    (object: unknown, options: ValidateOptions): Validate;
+    globalConfig: GlobalConfig;
+    setGlobalConfig(options: GlobalConfig): void;
+};
+declare class Validate {
+    number: NumberValidator;
+    string: StringValidator;
+    array: ArrayValidator;
+    object: ObjectValidator;
+    boolean: BooleanValidator;
+    type: TypeValidator;
+    custom: CustomValidator;
+    constructor(object: unknown, _options: InnerValidateOptions);
+}
+declare class Schema {
+    schema: SchemaType;
+    options: ValidateOptions;
+    constructor(schema: SchemaType, options?: ValidateOptions);
+    messages(validateMessages: ValidateMessagesType): void;
+    validate(values: {
+        [key: string]: unknown;
+    }, callback: any): void;
+}
+export { ArrayValidator, BooleanValidator, CustomValidator, zhCNValidateLocale as defaultValidateLocale, DefaultValidateMessage, enUSValidateLocale, mergeTemplate, NumberValidator, ObjectValidator, Schema, StringValidator, TypeValidator, zhCNValidateLocale, };
+export default PqbValidate;
+export type { CustomValidatorType, GlobalConfig, InnerValidateOptions, RuleType, SchemaRuleType, SchemaType, ValidateMessagesTemplateType, ValidateMessagesType, ValidateOptions, ValidatorError, } from './interface';