@unicom-cloud/utils 0.1.11 → 0.1.13

package/types/lunar/lib/Solar.d.ts

@@ -0,0 +1,51 @@
+import { Lunar } from './Lunar';
+import { SolarWeek } from './SolarWeek';
+export declare class Solar {
+    static J2000: number;
+    private readonly _year;
+    private readonly _month;
+    private readonly _day;
+    private readonly _hour;
+    private readonly _minute;
+    private readonly _second;
+    static fromYmd(year: number, month: number, day: number): Solar;
+    static fromYmdHms(year: number, month: number, day: number, hour: number, minute: number, second: number): Solar;
+    static fromDate(date: Date): Solar;
+    static fromJulianDay(julianDay: number): Solar;
+    static fromBaZi(yearGanZhi: string, monthGanZhi: string, dayGanZhi: string, timeGanZhi: string, sect?: number, baseYear?: number): Solar[];
+    constructor(year: number, month: number, day: number, hour: number, minute: number, second: number);
+    getYear(): number;
+    getMonth(): number;
+    getDay(): number;
+    getHour(): number;
+    getMinute(): number;
+    getSecond(): number;
+    getWeek(): number;
+    getWeekInChinese(): string;
+    getSolarWeek(start: number): SolarWeek;
+    isLeapYear(): boolean;
+    getFestivals(): string[];
+    getOtherFestivals(): string[];
+    getXingzuo(): string;
+    getXingZuo(): string;
+    /**
+     * 获取薪资比例(感谢 https://gitee.com/smr1987)
+     * @returns 1 | 2 | 3 薪资比例
+     */
+    getSalaryRate(): number;
+    toYmd(): string;
+    toYmdHms(): string;
+    toString(): string;
+    toFullString(): string;
+    nextYear(years: number): Solar;
+    nextMonth(months: number): Solar;
+    nextDay(days: number): Solar;
+    next(days: number, onlyWorkday?: boolean): Solar;
+    nextHour(hours: number): Solar;
+    getLunar(): Lunar;
+    getJulianDay(): number;
+    isBefore(solar: Solar): boolean;
+    isAfter(solar: Solar): boolean;
+    subtract(solar: Solar): number;
+    subtractMinute(solar: Solar): number;
+}

package/types/lunar/lib/SolarHalfYear.d.ts

@@ -0,0 +1,15 @@
+import { SolarMonth } from './SolarMonth';
+export declare class SolarHalfYear {
+    private readonly _year;
+    private readonly _month;
+    static fromYm(year: number, month: number): SolarHalfYear;
+    static fromDate(date: Date): SolarHalfYear;
+    constructor(year: number, month: number);
+    getYear(): number;
+    getMonth(): number;
+    getIndex(): number;
+    next(halfYears: number): SolarHalfYear;
+    getMonths(): SolarMonth[];
+    toString(): string;
+    toFullString(): string;
+}

package/types/lunar/lib/SolarMonth.d.ts

@@ -0,0 +1,16 @@
+import { Solar } from './Solar';
+import { SolarWeek } from './SolarWeek';
+export declare class SolarMonth {
+    private readonly _year;
+    private readonly _month;
+    static fromYm(year: number, month: number): SolarMonth;
+    static fromDate(date: Date): SolarMonth;
+    constructor(year: number, month: number);
+    getYear(): number;
+    getMonth(): number;
+    next(months: number): SolarMonth;
+    getDays(): Solar[];
+    getWeeks(start: number): SolarWeek[];
+    toString(): string;
+    toFullString(): string;
+}

package/types/lunar/lib/SolarSeason.d.ts

@@ -0,0 +1,15 @@
+import { SolarMonth } from './SolarMonth';
+export declare class SolarSeason {
+    private readonly _year;
+    private readonly _month;
+    static fromYm(year: number, month: number): SolarSeason;
+    static fromDate(date: Date): SolarSeason;
+    constructor(year: number, month: number);
+    getYear(): number;
+    getMonth(): number;
+    getIndex(): number;
+    next(seasons: number): SolarSeason;
+    getMonths(): SolarMonth[];
+    toString(): string;
+    toFullString(): string;
+}

package/types/lunar/lib/SolarUtil.d.ts

@@ -0,0 +1,20 @@
+export declare class SolarUtil {
+    static WEEK: string[];
+    static DAYS_OF_MONTH: number[];
+    static XINGZUO: string[];
+    static FESTIVAL: {
+        [key: string]: string;
+    };
+    static OTHER_FESTIVAL: {
+        [key: string]: string[];
+    };
+    static WEEK_FESTIVAL: {
+        [key: string]: string;
+    };
+    static isLeapYear(year: number): boolean;
+    static getDaysOfMonth(year: number, month: number): number;
+    static getDaysOfYear(year: number): number;
+    static getDaysInYear(year: number, month: number, day: number): number;
+    static getWeeksOfMonth(year: number, month: number, start: number): number;
+    static getDaysBetween(ay: number, am: number, ad: number, by: number, bm: number, bd: number): number;
+}

package/types/lunar/lib/SolarWeek.d.ts

@@ -0,0 +1,23 @@
+import { Solar } from './Solar';
+export declare class SolarWeek {
+    private readonly _year;
+    private readonly _month;
+    private readonly _day;
+    private readonly _start;
+    static fromYmd(year: number, month: number, day: number, start: number): SolarWeek;
+    static fromDate(date: Date, start: number): SolarWeek;
+    constructor(year: number, month: number, day: number, start: number);
+    getYear(): number;
+    getMonth(): number;
+    getDay(): number;
+    getStart(): number;
+    getIndex(): number;
+    getIndexInYear(): number;
+    next(weeks: number, separateMonth: boolean): SolarWeek;
+    getFirstDay(): Solar;
+    getFirstDayInMonth(): Solar;
+    getDays(): Solar[];
+    getDaysInMonth(): Solar[];
+    toString(): string;
+    toFullString(): string;
+}

package/types/lunar/lib/SolarYear.d.ts

@@ -0,0 +1,12 @@
+import { SolarMonth } from './SolarMonth';
+export declare class SolarYear {
+    private readonly _year;
+    static fromYear(year: number): SolarYear;
+    static fromDate(date: Date): SolarYear;
+    constructor(year: number);
+    getYear(): number;
+    next(years: number): SolarYear;
+    getMonths(): SolarMonth[];
+    toString(): string;
+    toFullString(): string;
+}

package/types/lunar/lib/index.d.ts

@@ -0,0 +1,17 @@
+import { Holiday } from './Holiday';
+import { HolidayUtil } from './HolidayUtil';
+import { JieQi } from './JieQi';
+import { Lunar } from './Lunar';
+import { LunarUtil } from './LunarUtil';
+import { Solar } from './Solar';
+import { SolarUtil } from './SolarUtil';
+import { SolarHalfYear } from './SolarHalfYear';
+import { SolarMonth } from './SolarMonth';
+import { SolarSeason } from './SolarSeason';
+import { SolarWeek } from './SolarWeek';
+import { SolarYear } from './SolarYear';
+import { I18n } from './I18n';
+import { LunarMonth } from './LunarMonth';
+import { LunarTime } from './LunarTime';
+import { LunarYear } from './LunarYear';
+export { Holiday, HolidayUtil, I18n, JieQi, Lunar, LunarMonth, LunarTime, LunarUtil, LunarYear, Solar, SolarHalfYear, SolarMonth, SolarSeason, SolarUtil, SolarWeek, SolarYear, };

package/types/snapdom/src/core/cache.d.ts

@@ -1,11 +1,17 @@
-/**
- * Caches for images, backgrounds, resources, and computed styles used during DOM capture.
- * @module cache
- */
-export const imageCache: Map<any, any>;
-export const bgCache: Map<any, any>;
-export const resourceCache: Map<any, any>;
-export const defaultStylesCache: Map<any, any>;
-export const baseCSSCache: Map<any, any>;
-export const computedStyleCache: WeakMap<WeakKey, any>;
-export const processedFontURLs: Set<any>;
+export namespace cache {
+    export let image: Map<any, any>;
+    export let background: Map<any, any>;
+    export let resource: Map<any, any>;
+    export let defaultStyle: Map<any, any>;
+    export let baseStyle: Map<any, any>;
+    export let computedStyle: WeakMap<WeakKey, any>;
+    export let font: Set<any>;
+    export let snapshot: WeakMap<WeakKey, any>;
+    export let snapshotKey: Map<any, any>;
+    export let preStyleMap: Map<any, any>;
+    export let preStyle: WeakMap<WeakKey, any>;
+    export let preNodeMap: Map<any, any>;
+    export { resetCache as reset };
+}
+declare function resetCache(): void;
+export {};

package/types/snapdom/src/core/capture.d.ts

@@ -7,6 +7,8 @@
  * @param {boolean} [options.embedFonts=false] - Whether to embed custom fonts
  * @param {boolean} [options.fast=true] - Whether to skip idle delay for faster results
  * @param {number} [options.scale=1] - Output scale multiplier
+ * @param {string[]} [options.exclude] - CSS selectors for elements to exclude
+ * @param {Function} [options.filter] - Custom filter function
  * @returns {Promise<string>} Promise that resolves to an SVG data URL
  */
 export function captureDOM(element: Element, options?: {
@@ -14,4 +16,6 @@ export function captureDOM(element: Element, options?: {
     embedFonts?: boolean | undefined;
     fast?: boolean | undefined;
     scale?: number | undefined;
+    exclude?: string[] | undefined;
+    filter?: Function | undefined;
 }): Promise<string>;

package/types/snapdom/src/core/clone.d.ts

@@ -2,10 +2,9 @@
  * Creates a deep clone of a DOM node, including styles, shadow DOM, and special handling for excluded/placeholder/canvas nodes.
  *
  * @param {Node} node - Node to clone
- * @param {Map} styleMap - Map to store element-to-style-key mappings
- * @param {WeakMap} styleCache - Cache of computed styles
- * @param {WeakMap} nodeMap - Map to track original-to-clone node relationships
  * @param {boolean} compress - Whether to compress style keys
- * @returns {Node|null} Cloned node with styles and shadow DOM content, or null for empty text nodes
+ * @param {Object} [options={}] - Capture options including exclude and filter
+ * @param {Node} [originalRoot] - Original root element being captured
+ * @returns {Node|null} Cloned node with styles and shadow DOM content, or null for empty text nodes or filtered elements
  */
-export function deepClone(node: Node, styleMap: Map<any, any>, styleCache: WeakMap<any, any>, nodeMap: WeakMap<any, any>, compress: boolean): Node | null;
+export function deepClone(node: Node, compress: boolean, options?: Object, originalRoot?: Node): Node | null;

package/types/snapdom/src/core/prepare.d.ts

@@ -3,6 +3,13 @@
  *
  * @param {Element} element - Element to clone
  * @param {boolean} [compress=false] - Whether to compress style keys
+ * @param {boolean} [embedFonts=false] - Whether to embed custom fonts
+ * @param {Object} [options={}] - Capture options
+ * @param {string[]} [options.exclude] - CSS selectors for elements to exclude
+ * @param {Function} [options.filter] - Custom filter function
  * @returns {Promise<Object>} Object containing the clone, generated CSS, and style cache
  */
-export function prepareClone(element: Element, compress?: boolean, embedFonts?: boolean): Promise<Object>;
+export function prepareClone(element: Element, compress?: boolean, embedFonts?: boolean, options?: {
+    exclude?: string[] | undefined;
+    filter?: Function | undefined;
+}): Promise<Object>;

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

@@ -3,8 +3,7 @@
  *
  * @param {Element} source - Original element
  * @param {Element} clone - Cloned element
- * @param {WeakMap} styleCache - Cache of computed styles
  * @param {Object} [options={}] - Options for image processing
  * @returns {Promise<void>} Promise that resolves when all background images are processed
  */
-export function inlineBackgroundImages(source: Element, clone: Element, styleCache: WeakMap<any, any>, options?: Object): Promise<void>;
+export function inlineBackgroundImages(source: Element, clone: Element, options?: Object): Promise<void>;

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

@@ -15,11 +15,9 @@ export function iconToImage(unicodeChar: string, fontFamily: string, fontWeight:
  *
  * @export
  * @param {Object} options
- * @param {boolean} [options.ignoreIconFonts=true] - Whether to skip icon fonts
  * @param {boolean} [options.preCached=false] - Whether to use pre-cached resources
  * @returns {Promise<string>} The inlined CSS for custom fonts
  */
-export function embedCustomFonts({ ignoreIconFonts, preCached, }?: {
-    ignoreIconFonts?: boolean | undefined;
+export function embedCustomFonts({ preCached }?: {
     preCached?: boolean | undefined;
 }): Promise<string>;

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

@@ -0,0 +1,2 @@
+export function extendIconFonts(fonts: any): void;
+export function isIconFont(input: any): boolean;

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

@@ -3,10 +3,8 @@
  *
  * @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>;
+export function inlinePseudoElements(source: Element, clone: Element, compress: boolean, embedFonts: boolean | undefined, useProxy: any): Promise<any>;

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

@@ -1,10 +1 @@
-/**
- * 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;
+export function inlineAllStyles(source: any, clone: any, compress: any): void;

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

@@ -0,0 +1,19 @@
+/**
+ * Inlines external `<defs>` used by `<use xlink:href="#...">` or `<use href="#...">` inside SVGs,
+ * copying only the necessary definitions into each individual cloned SVG.
+ *
+ * This is needed because cloned SVGs using `<use>` may reference elements like `<symbol>`, `<path>`, etc.,
+ * defined elsewhere in the document (e.g., in a shared `<defs>` block that is not part of the cloned subtree).
+ *
+ * The function finds all `<use>` elements within `root`, extracts the referenced IDs,
+ * and embeds the required definitions at the top of each SVG.
+ *
+ * @function inlineExternalDef
+ * @param {ParentNode} root - The root node containing cloned SVGs (usually the result of a DOM snapshot).
+ * @returns {void}
+ *
+ * @example
+ * const { clone } = await prepareClone(element);
+ * inlineExternalDef(clone);
+ */
+export function inlineExternalDef(root: ParentNode): void;

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

@@ -32,7 +32,6 @@ 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>;
+export function generateCSSClasses(): Map<any, any>;

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

@@ -56,7 +56,7 @@ export function isIconFont(familyOrUrl: string): boolean;
  * @param {number} [timeout=3000]
  * @return {*}
  */
-export function fetchImage(src: any, timeout?: number, crossOrigin?: string): any;
+export function fetchImage(src: any, { timeout, useProxy }?: number): any;
 /**
  *
  *

package/types/tinycolor/index.d.ts

@@ -0,0 +1,2 @@
+export * from './src/public_api';
+export { TinyColor as default } from './src';

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

@@ -0,0 +1,79 @@
+import { HSL, HSV, Numberify, RGB } from './interfaces.js';
+/**
+ * Handle bounds / percentage checking to conform to CSS color spec
+ * <http://www.w3.org/TR/css3-color/>
+ * *Assumes:* r, g, b in [0, 255] or [0, 1]
+ * *Returns:* { r, g, b } in [0, 255]
+ */
+export declare function rgbToRgb(r: number | string, g: number | string, b: number | string): Numberify<RGB>;
+/**
+ * Converts an RGB color value to HSL.
+ * *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]
+ * *Returns:* { h, s, l } in [0,1]
+ */
+export declare function rgbToHsl(r: number, g: number, b: number): Numberify<HSL>;
+/**
+ * Converts an HSL color value to RGB.
+ *
+ * *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
+ * *Returns:* { r, g, b } in the set [0, 255]
+ */
+export declare function hslToRgb(h: number | string, s: number | string, l: number | string): Numberify<RGB>;
+/**
+ * Converts an RGB color value to HSV
+ *
+ * *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
+ * *Returns:* { h, s, v } in [0,1]
+ */
+export declare function rgbToHsv(r: number, g: number, b: number): Numberify<HSV>;
+/**
+ * Converts an HSV color value to RGB.
+ *
+ * *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
+ * *Returns:* { r, g, b } in the set [0, 255]
+ */
+export declare function hsvToRgb(h: number | string, s: number | string, v: number | string): Numberify<RGB>;
+/**
+ * Converts an RGB color to hex
+ *
+ * *Assumes:* r, g, and b are contained in the set [0, 255]
+ * *Returns:* a 3 or 6 character hex
+ */
+export declare function rgbToHex(r: number, g: number, b: number, allow3Char: boolean): string;
+/**
+ * Converts an RGBA color plus alpha transparency to hex
+ *
+ * *Assumes:* r, g, b are contained in the set [0, 255] and a in [0, 1]
+ * *Returns:* a 4 or 8 character rgba hex
+ */
+export declare function rgbaToHex(r: number, g: number, b: number, a: number, allow4Char: boolean): string;
+/**
+ * Converts an RGBA color to an ARGB Hex8 string
+ * Rarely used, but required for "toFilter()"
+ *
+ * *Assumes:* r, g, b are contained in the set [0, 255] and a in [0, 1]
+ * *Returns:* a 8 character argb hex
+ */
+export declare function rgbaToArgbHex(r: number, g: number, b: number, a: number): string;
+/**
+ * Converts CMYK to RBG
+ * Assumes c, m, y, k are in the set [0, 100]
+ */
+export declare function cmykToRgb(c: number, m: number, y: number, k: number): {
+    r: number;
+    g: number;
+    b: number;
+};
+export declare function rgbToCmyk(r: number, g: number, b: number): {
+    c: number;
+    m: number;
+    y: number;
+    k: number;
+};
+/** Converts a decimal to a hex value */
+export declare function convertDecimalToHex(d: string | number): string;
+/** Converts a hex value to a decimal */
+export declare function convertHexToDecimal(h: string): number;
+/** Parse a base-16 hex value into a base-10 integer */
+export declare function parseIntFromHex(val: string): number;
+export declare function numberInputToObject(color: number): RGB;

package/types/tinycolor/src/css-color-names.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @hidden
+ */
+export declare const names: Record<string, string>;

package/types/tinycolor/src/format-input.d.ts

@@ -0,0 +1,38 @@
+import { CMYK, HSL, HSLA, HSV, HSVA, RGB, RGBA } from './interfaces.js';
+/**
+ * Given a string or object, convert that input to RGB
+ *
+ * Possible string inputs:
+ * ```
+ * "red"
+ * "#f00" or "f00"
+ * "#ff0000" or "ff0000"
+ * "#ff000000" or "ff000000"
+ * "rgb 255 0 0" or "rgb (255, 0, 0)"
+ * "rgb 1.0 0 0" or "rgb (1, 0, 0)"
+ * "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1"
+ * "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1"
+ * "hsl(0, 100%, 50%)" or "hsl 0 100% 50%"
+ * "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
+ * "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
+ * "cmyk(0, 20, 0, 0)" or "cmyk 0 20 0 0"
+ * ```
+ */
+export declare function inputToRGB(color: string | RGB | RGBA | HSL | HSLA | HSV | HSVA | CMYK | any): {
+    ok: boolean;
+    format: any;
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+/**
+ * Permissive string parsing.  Take in a number of formats, and output an object
+ * based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}` or `{c, m, y, k}` or `{c, m, y, k, a}`
+ */
+export declare function stringInputToObject(color: string): any;
+/**
+ * Check to see if it looks like a CSS unit
+ * (see `matchers` above for definition).
+ */
+export declare function isValidCSSUnit(color: string | number): boolean;

package/types/tinycolor/src/from-ratio.d.ts

@@ -0,0 +1,14 @@
+import { TinyColor } from './index.js';
+export interface RatioInput {
+    r: number | string;
+    g: number | string;
+    b: number | string;
+    a?: number | string;
+}
+/**
+ * If input is an object, force 1 into "1.0" to handle ratios properly
+ * String input requires "1.0" as input, so 1 will be treated as 1
+ */
+export declare function fromRatio(ratio: RatioInput, opts?: any): TinyColor;
+/** old random function */
+export declare function legacyRandom(): TinyColor;