@unicom-cloud/utils 0.1.5 → 0.1.11

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

@@ -0,0 +1,8 @@
+/**
+ * Converts all <img> elements in the clone to data URLs or replaces them with placeholders if loading fails.
+ *
+ * @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
+ */
+export function inlineImages(clone: Element, options?: Object): Promise<void>;

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

@@ -0,0 +1,12 @@
+/**
+ * Creates elements to represent ::before, ::after, and ::first-letter pseudo-elements, inlining their styles and content.
+ *
+ * @param {Element} source - Original element
+ * @param {Element} clone - Cloned element
+ * @param {Map} styleMap - Map to store element-to-style-key mappings
+ * @param {WeakMap} styleCache - Cache of computed styles
+ * @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
+ */
+export function inlinePseudoElements(source: Element, clone: Element, styleMap: Map<any, any>, styleCache: WeakMap<any, any>, compress: boolean, embedFonts?: boolean): Promise<any>;

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

@@ -0,0 +1,10 @@
+/**
+ * Records computed styles for an element to later generate CSS classes.
+ *
+ * @param {Element} source - Original element
+ * @param {Element} clone - Cloned element
+ * @param {Map} styleMap - Map to store element-to-style-key mappings
+ * @param {WeakMap} cache - Cache of computed styles
+ * @param {boolean} compress - Whether to compress style keys
+ */
+export function inlineAllStyles(source: Element, clone: Element, styleMap: Map<any, any>, cache: WeakMap<any, any>, compress: boolean): void;

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

@@ -0,0 +1,38 @@
+export function precacheCommonTags(): void;
+/**
+ * Retrieves default CSS property values from a temporary element.
+ *
+ * @param {string} tagName - The tag name to get default styles for
+ * @returns {Object} Object containing default values for all CSS properties
+ */
+export function getDefaultStyleForTag(tagName: string): Object;
+/**
+ * Creates a unique key from an element's computed style that differs from defaults.
+ *
+ * @param {Object} snapshot - Computed style snapshot
+ * @param {string} tagName - The tag name of the element
+ * @param {boolean} [compress=false] - Whether to compress style keys
+ * @returns {string} Semi-colon separated list of non-default properties
+ */
+export function getStyleKey(snapshot: Object, tagName: string, compress?: boolean): 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.
+ *
+ * @param {Map} styleMap - Map of elements to style keys
+ * @returns {Map} Map of style keys to class names
+ */
+export function generateCSSClasses(styleMap: Map<any, any>): Map<any, any>;

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

@@ -0,0 +1,71 @@
+/**
+ * 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.
+ *
+ * @param {string} value - The CSS value
+ * @returns {string|null} The extracted URL or null
+ */
+export function extractURL(value: string): string | null;
+/**
+ * Determines if a font family or URL is an icon font.
+ *
+ * @param {string} familyOrUrl - The font family or URL
+ * @returns {boolean} True if it is an icon font
+ */
+export function isIconFont(familyOrUrl: string): boolean;
+/**
+ *
+ *
+ * @export
+ * @param {*} src
+ * @param {number} [timeout=3000]
+ * @return {*}
+ */
+export function fetchImage(src: any, timeout?: number, crossOrigin?: string): 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/tree/index.d.ts

@@ -0,0 +1,8 @@
+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 getItemBy2(root: any, key: any, value: any, childrenKey?: string): any;
+export default getItemBy;

package/types/turbo-stream/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/turbo-stream";

package/types/turbo-stream/src/decode.d.ts

@@ -0,0 +1,7 @@
+export type DecodePlugin = (type: string, ...data: unknown[]) => {
+    value: unknown;
+} | false | null | undefined;
+export type DecodeOptions = {
+    plugins?: DecodePlugin[];
+};
+export declare function decode<T>(stream: ReadableStream<string>, { plugins }?: DecodeOptions): Promise<T>;

package/types/turbo-stream/src/encode.d.ts

@@ -0,0 +1,27 @@
+declare const ASYNC_FRAME_TYPE_PROMISE = 1;
+declare const ASYNC_FRAME_TYPE_ITERABLE = 2;
+type AsyncFrame = [
+    type: typeof ASYNC_FRAME_TYPE_PROMISE,
+    id: number,
+    promise: PromiseLike<unknown>
+] | [
+    type: typeof ASYNC_FRAME_TYPE_ITERABLE,
+    id: number,
+    iterable: AsyncIterable<unknown>
+];
+export type EncodePlugin = (value: unknown) => [string, ...unknown[]] | false | null | undefined;
+export type EncodeOptions = {
+    plugins?: EncodePlugin[];
+    redactErrors?: boolean | string;
+    signal?: AbortSignal;
+};
+export declare function encode(value: unknown, { plugins, redactErrors, signal }?: EncodeOptions): ReadableStream<string>;
+export declare function encodeSync(value: unknown, chunks: {
+    push(...chunk: string[]): void;
+}, refs: WeakMap<object, number>, promises: WeakMap<object, number>, asyncFrames: {
+    push(frame: AsyncFrame): void;
+}, counters: {
+    refId: number;
+    promiseId: number;
+}, plugins: EncodePlugin[], redactErrors: boolean | string): void;
+export {};

package/types/turbo-stream/src/shared.d.ts

@@ -0,0 +1,107 @@
+export declare const STR_ARRAY_BUFFER = "A";
+export declare const STR_ASYNC_ITERABLE = "*";
+export declare const STR_BIG_INT_64_ARRAY = "J";
+export declare const STR_BIG_UINT_64_ARRAY = "j";
+export declare const STR_BIGINT = "b";
+export declare const STR_BLOB = "K";
+export declare const STR_DATA_VIEW = "V";
+export declare const STR_DATE = "D";
+export declare const STR_ERROR = "E";
+export declare const STR_FAILURE = "!";
+export declare const STR_FALSE = "false";
+export declare const STR_FILE = "k";
+export declare const STR_FLOAT_32_ARRAY = "H";
+export declare const STR_FLOAT_64_ARRAY = "h";
+export declare const STR_FORM_DATA = "F";
+export declare const STR_INFINITY = "I";
+export declare const STR_INT_16_ARRAY = "L";
+export declare const STR_INT_32_ARRAY = "G";
+export declare const STR_INT_8_ARRAY = "O";
+export declare const STR_MAP = "M";
+export declare const STR_NaN = "NaN";
+export declare const STR_NEGATIVE_INFINITY = "i";
+export declare const STR_NEGATIVE_ZERO = "z";
+export declare const STR_NULL = "null";
+export declare const STR_PLUGIN = "P";
+export declare const STR_PROMISE = "$";
+export declare const STR_READABLE_STREAM = "R";
+export declare const STR_REDACTED = "<redacted>";
+export declare const STR_REFERENCE_SYMBOL = "@";
+export declare const STR_REGEXP = "r";
+export declare const STR_SET = "S";
+export declare const STR_SUCCESS = ":";
+export declare const STR_SYMBOL = "s";
+export declare const STR_TRUE = "true";
+export declare const STR_UINT_16_ARRAY = "l";
+export declare const STR_UINT_32_ARRAY = "g";
+export declare const STR_UINT_8_ARRAY = "o";
+export declare const STR_UINT_8_ARRAY_CLAMPED = "C";
+export declare const STR_UNDEFINED = "u";
+export declare const STR_URL = "U";
+declare let SUPPORTS_FILE: boolean;
+export { SUPPORTS_FILE };
+export declare class WaitGroup {
+    #private;
+    p: number;
+    add(): void;
+    done(): void;
+    wait(): Promise<void>;
+}
+export declare class Deferred<T> {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (error: unknown) => void;
+    constructor();
+}
+export declare class DeferredAsyncIterable<T> {
+    #private;
+    iterable: AsyncIterable<T>;
+    constructor();
+    resolve(): void;
+    reject(error: unknown): void;
+    yield(value: T): void;
+}
+export declare class DeferredReadableStream<T> extends DeferredAsyncIterable<T> {
+    readable: ReadableStream<T>;
+}
+export declare class TurboBlob extends Blob {
+    #private;
+    promise?: Promise<ArrayBuffer>;
+    constructor();
+    constructor(from: TurboBlob, start: number | undefined, end: number | undefined, contentType: string | undefined);
+    get size(): number;
+    set size(value: number);
+    get type(): string;
+    set type(value: string);
+    arrayBuffer(): Promise<ArrayBuffer>;
+    bytes(): Promise<Uint8Array>;
+    slice(start?: number, end?: number, contentType?: string): Blob;
+    stream(): ReadableStream<Uint8Array>;
+    text(): Promise<string>;
+}
+declare const FileBaseClass: {
+    new (fileBits: BlobPart[], fileName: string, options?: FilePropertyBag): File;
+    prototype: File;
+} | {
+    new (blobParts?: BlobPart[], options?: BlobPropertyBag): Blob;
+    prototype: Blob;
+};
+export declare class TurboFile extends FileBaseClass {
+    #private;
+    promise?: Promise<ArrayBuffer>;
+    constructor();
+    constructor(from: TurboFile, start: number | undefined, end: number | undefined, contentType: string | undefined);
+    get name(): string;
+    set name(value: string);
+    get lastModified(): number;
+    set lastModified(value: number);
+    get size(): number;
+    set size(value: number);
+    get type(): string;
+    set type(value: string);
+    arrayBuffer(): Promise<ArrayBuffer>;
+    bytes(): Promise<Uint8Array>;
+    slice(start?: number, end?: number, contentType?: string): Blob;
+    stream(): ReadableStream<Uint8Array>;
+    text(): Promise<string>;
+}

package/types/turbo-stream/src/turbo-stream.d.ts

@@ -0,0 +1,4 @@
+export { decode } from './decode.js';
+export type { DecodeOptions, DecodePlugin } from './decode.js';
+export { encode } from './encode.js';
+export type { EncodeOptions, EncodePlugin } from './encode.js';

package/types/url-toolkit/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./src/url-toolkit";
+export { "/Users/panqibao/work/ui/utils/url-toolkit/src/url-toolkit" as default } from "./src/url-toolkit";

package/types/url-toolkit/src/url-toolkit.d.ts

@@ -0,0 +1,18 @@
+declare namespace _default {
+    export { buildAbsoluteURL };
+    export { parseURL };
+    export { normalizePath };
+    export { buildURLFromParts };
+}
+export default _default;
+export function buildAbsoluteURL(baseURL: any, relativeURL: any, opts: any): any;
+export function buildURLFromParts(parts: any): any;
+export function normalizePath(path: any): any;
+export function parseURL(url: any): {
+    scheme: string;
+    netLoc: string;
+    path: string;
+    params: string;
+    query: string;
+    fragment: string;
+} | null;

package/urlToolkit.js

@@ -0,0 +1,8 @@
+import { buildAbsoluteURL as e, buildURLFromParts as l, default as o, normalizePath as t, parseURL as u } from "./url-toolkit/src/url-toolkit.js";
+export {
+  e as buildAbsoluteURL,
+  l as buildURLFromParts,
+  o as default,
+  t as normalizePath,
+  u as parseURL
+};