@nocobase/plugin-gantt 2.1.0-beta.37 → 2.1.0-beta.38

package/dist/node_modules/@ctrl/tinycolor/dist/format-input.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidCSSUnit = exports.stringInputToObject = exports.inputToRGB = void 0;
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
+var conversion_js_1 = require("./conversion.js");
+var css_color_names_js_1 = require("./css-color-names.js");
+var util_js_1 = require("./util.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%"
+ * ```
+ */
+function inputToRGB(color) {
+    var rgb = { r: 0, g: 0, b: 0 };
+    var a = 1;
+    var s = null;
+    var v = null;
+    var l = null;
+    var ok = false;
+    var format = false;
+    if (typeof color === 'string') {
+        color = stringInputToObject(color);
+    }
+    if (typeof color === 'object') {
+        if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
+            rgb = (0, conversion_js_1.rgbToRgb)(color.r, color.g, color.b);
+            ok = true;
+            format = String(color.r).substr(-1) === '%' ? 'prgb' : 'rgb';
+        }
+        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
+            s = (0, util_js_1.convertToPercentage)(color.s);
+            v = (0, util_js_1.convertToPercentage)(color.v);
+            rgb = (0, conversion_js_1.hsvToRgb)(color.h, s, v);
+            ok = true;
+            format = 'hsv';
+        }
+        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
+            s = (0, util_js_1.convertToPercentage)(color.s);
+            l = (0, util_js_1.convertToPercentage)(color.l);
+            rgb = (0, conversion_js_1.hslToRgb)(color.h, s, l);
+            ok = true;
+            format = 'hsl';
+        }
+        if (Object.prototype.hasOwnProperty.call(color, 'a')) {
+            a = color.a;
+        }
+    }
+    a = (0, util_js_1.boundAlpha)(a);
+    return {
+        ok: ok,
+        format: color.format || format,
+        r: Math.min(255, Math.max(rgb.r, 0)),
+        g: Math.min(255, Math.max(rgb.g, 0)),
+        b: Math.min(255, Math.max(rgb.b, 0)),
+        a: a,
+    };
+}
+exports.inputToRGB = inputToRGB;
+// <http://www.w3.org/TR/css3-values/#integers>
+var CSS_INTEGER = '[-\\+]?\\d+%?';
+// <http://www.w3.org/TR/css3-values/#number-value>
+var CSS_NUMBER = '[-\\+]?\\d*\\.\\d+%?';
+// Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
+var CSS_UNIT = "(?:".concat(CSS_NUMBER, ")|(?:").concat(CSS_INTEGER, ")");
+// Actual matching.
+// Parentheses and commas are optional, but not required.
+// Whitespace can take the place of commas or opening paren
+var PERMISSIVE_MATCH3 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
+var PERMISSIVE_MATCH4 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
+var matchers = {
+    CSS_UNIT: new RegExp(CSS_UNIT),
+    rgb: new RegExp('rgb' + PERMISSIVE_MATCH3),
+    rgba: new RegExp('rgba' + PERMISSIVE_MATCH4),
+    hsl: new RegExp('hsl' + PERMISSIVE_MATCH3),
+    hsla: new RegExp('hsla' + PERMISSIVE_MATCH4),
+    hsv: new RegExp('hsv' + PERMISSIVE_MATCH3),
+    hsva: new RegExp('hsva' + PERMISSIVE_MATCH4),
+    hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+    hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
+    hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+    hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
+};
+/**
+ * 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}`
+ */
+function stringInputToObject(color) {
+    color = color.trim().toLowerCase();
+    if (color.length === 0) {
+        return false;
+    }
+    var named = false;
+    if (css_color_names_js_1.names[color]) {
+        color = css_color_names_js_1.names[color];
+        named = true;
+    }
+    else if (color === 'transparent') {
+        return { r: 0, g: 0, b: 0, a: 0, format: 'name' };
+    }
+    // Try to match string input using regular expressions.
+    // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
+    // Just return an object and let the conversion functions handle that.
+    // This way the result will be the same whether the tinycolor is initialized with string or object.
+    var match = matchers.rgb.exec(color);
+    if (match) {
+        return { r: match[1], g: match[2], b: match[3] };
+    }
+    match = matchers.rgba.exec(color);
+    if (match) {
+        return { r: match[1], g: match[2], b: match[3], a: match[4] };
+    }
+    match = matchers.hsl.exec(color);
+    if (match) {
+        return { h: match[1], s: match[2], l: match[3] };
+    }
+    match = matchers.hsla.exec(color);
+    if (match) {
+        return { h: match[1], s: match[2], l: match[3], a: match[4] };
+    }
+    match = matchers.hsv.exec(color);
+    if (match) {
+        return { h: match[1], s: match[2], v: match[3] };
+    }
+    match = matchers.hsva.exec(color);
+    if (match) {
+        return { h: match[1], s: match[2], v: match[3], a: match[4] };
+    }
+    match = matchers.hex8.exec(color);
+    if (match) {
+        return {
+            r: (0, conversion_js_1.parseIntFromHex)(match[1]),
+            g: (0, conversion_js_1.parseIntFromHex)(match[2]),
+            b: (0, conversion_js_1.parseIntFromHex)(match[3]),
+            a: (0, conversion_js_1.convertHexToDecimal)(match[4]),
+            format: named ? 'name' : 'hex8',
+        };
+    }
+    match = matchers.hex6.exec(color);
+    if (match) {
+        return {
+            r: (0, conversion_js_1.parseIntFromHex)(match[1]),
+            g: (0, conversion_js_1.parseIntFromHex)(match[2]),
+            b: (0, conversion_js_1.parseIntFromHex)(match[3]),
+            format: named ? 'name' : 'hex',
+        };
+    }
+    match = matchers.hex4.exec(color);
+    if (match) {
+        return {
+            r: (0, conversion_js_1.parseIntFromHex)(match[1] + match[1]),
+            g: (0, conversion_js_1.parseIntFromHex)(match[2] + match[2]),
+            b: (0, conversion_js_1.parseIntFromHex)(match[3] + match[3]),
+            a: (0, conversion_js_1.convertHexToDecimal)(match[4] + match[4]),
+            format: named ? 'name' : 'hex8',
+        };
+    }
+    match = matchers.hex3.exec(color);
+    if (match) {
+        return {
+            r: (0, conversion_js_1.parseIntFromHex)(match[1] + match[1]),
+            g: (0, conversion_js_1.parseIntFromHex)(match[2] + match[2]),
+            b: (0, conversion_js_1.parseIntFromHex)(match[3] + match[3]),
+            format: named ? 'name' : 'hex',
+        };
+    }
+    return false;
+}
+exports.stringInputToObject = stringInputToObject;
+/**
+ * Check to see if it looks like a CSS unit
+ * (see `matchers` above for definition).
+ */
+function isValidCSSUnit(color) {
+    return Boolean(matchers.CSS_UNIT.exec(String(color)));
+}
+exports.isValidCSSUnit = isValidCSSUnit;

package/dist/node_modules/@ctrl/tinycolor/dist/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;

package/dist/node_modules/@ctrl/tinycolor/dist/from-ratio.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.legacyRandom = exports.fromRatio = void 0;
+var index_js_1 = require("./index.js");
+var util_js_1 = require("./util.js");
+/**
+ * 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
+ */
+function fromRatio(ratio, opts) {
+    var newColor = {
+        r: (0, util_js_1.convertToPercentage)(ratio.r),
+        g: (0, util_js_1.convertToPercentage)(ratio.g),
+        b: (0, util_js_1.convertToPercentage)(ratio.b),
+    };
+    if (ratio.a !== undefined) {
+        newColor.a = Number(ratio.a);
+    }
+    return new index_js_1.TinyColor(newColor, opts);
+}
+exports.fromRatio = fromRatio;
+/** old random function */
+function legacyRandom() {
+    return new index_js_1.TinyColor({
+        r: Math.random(),
+        g: Math.random(),
+        b: Math.random(),
+    });
+}
+exports.legacyRandom = legacyRandom;

package/dist/node_modules/@ctrl/tinycolor/dist/index.d.ts

@@ -0,0 +1,207 @@
+import { HSL, HSLA, HSV, HSVA, Numberify, RGB, RGBA } from './interfaces.js';
+export interface TinyColorOptions {
+    format: string;
+    gradientType: string;
+}
+export type ColorInput = string | number | RGB | RGBA | HSL | HSLA | HSV | HSVA | TinyColor;
+export type ColorFormats = 'rgb' | 'prgb' | 'hex' | 'hex3' | 'hex4' | 'hex6' | 'hex8' | 'name' | 'hsl' | 'hsv';
+export declare class TinyColor {
+    /** red */
+    r: number;
+    /** green */
+    g: number;
+    /** blue */
+    b: number;
+    /** alpha */
+    a: number;
+    /** the format used to create the tinycolor instance */
+    format: ColorFormats;
+    /** input passed into the constructer used to create the tinycolor instance */
+    originalInput: ColorInput;
+    /** the color was successfully parsed */
+    isValid: boolean;
+    gradientType?: string;
+    /** rounded alpha */
+    roundA: number;
+    constructor(color?: ColorInput, opts?: Partial<TinyColorOptions>);
+    isDark(): boolean;
+    isLight(): boolean;
+    /**
+     * Returns the perceived brightness of the color, from 0-255.
+     */
+    getBrightness(): number;
+    /**
+     * Returns the perceived luminance of a color, from 0-1.
+     */
+    getLuminance(): number;
+    /**
+     * Returns the alpha value of a color, from 0-1.
+     */
+    getAlpha(): number;
+    /**
+     * Sets the alpha value on the current color.
+     *
+     * @param alpha - The new alpha value. The accepted range is 0-1.
+     */
+    setAlpha(alpha?: string | number): this;
+    /**
+     * Returns whether the color is monochrome.
+     */
+    isMonochrome(): boolean;
+    /**
+     * Returns the object as a HSVA object.
+     */
+    toHsv(): Numberify<HSVA>;
+    /**
+     * Returns the hsva values interpolated into a string with the following format:
+     * "hsva(xxx, xxx, xxx, xx)".
+     */
+    toHsvString(): string;
+    /**
+     * Returns the object as a HSLA object.
+     */
+    toHsl(): Numberify<HSLA>;
+    /**
+     * Returns the hsla values interpolated into a string with the following format:
+     * "hsla(xxx, xxx, xxx, xx)".
+     */
+    toHslString(): string;
+    /**
+     * Returns the hex value of the color.
+     * @param allow3Char will shorten hex value to 3 char if possible
+     */
+    toHex(allow3Char?: boolean): string;
+    /**
+     * Returns the hex value of the color -with a # prefixed.
+     * @param allow3Char will shorten hex value to 3 char if possible
+     */
+    toHexString(allow3Char?: boolean): string;
+    /**
+     * Returns the hex 8 value of the color.
+     * @param allow4Char will shorten hex value to 4 char if possible
+     */
+    toHex8(allow4Char?: boolean): string;
+    /**
+     * Returns the hex 8 value of the color -with a # prefixed.
+     * @param allow4Char will shorten hex value to 4 char if possible
+     */
+    toHex8String(allow4Char?: boolean): string;
+    /**
+     * Returns the shorter hex value of the color depends on its alpha -with a # prefixed.
+     * @param allowShortChar will shorten hex value to 3 or 4 char if possible
+     */
+    toHexShortString(allowShortChar?: boolean): string;
+    /**
+     * Returns the object as a RGBA object.
+     */
+    toRgb(): Numberify<RGBA>;
+    /**
+     * Returns the RGBA values interpolated into a string with the following format:
+     * "RGBA(xxx, xxx, xxx, xx)".
+     */
+    toRgbString(): string;
+    /**
+     * Returns the object as a RGBA object.
+     */
+    toPercentageRgb(): RGBA;
+    /**
+     * Returns the RGBA relative values interpolated into a string
+     */
+    toPercentageRgbString(): string;
+    /**
+     * The 'real' name of the color -if there is one.
+     */
+    toName(): string | false;
+    /**
+     * String representation of the color.
+     *
+     * @param format - The format to be used when displaying the string representation.
+     */
+    toString<T extends 'name'>(format: T): boolean | string;
+    toString<T extends ColorFormats>(format?: T): string;
+    toNumber(): number;
+    clone(): TinyColor;
+    /**
+     * Lighten the color a given amount. Providing 100 will always return white.
+     * @param amount - valid between 1-100
+     */
+    lighten(amount?: number): TinyColor;
+    /**
+     * Brighten the color a given amount, from 0 to 100.
+     * @param amount - valid between 1-100
+     */
+    brighten(amount?: number): TinyColor;
+    /**
+     * Darken the color a given amount, from 0 to 100.
+     * Providing 100 will always return black.
+     * @param amount - valid between 1-100
+     */
+    darken(amount?: number): TinyColor;
+    /**
+     * Mix the color with pure white, from 0 to 100.
+     * Providing 0 will do nothing, providing 100 will always return white.
+     * @param amount - valid between 1-100
+     */
+    tint(amount?: number): TinyColor;
+    /**
+     * Mix the color with pure black, from 0 to 100.
+     * Providing 0 will do nothing, providing 100 will always return black.
+     * @param amount - valid between 1-100
+     */
+    shade(amount?: number): TinyColor;
+    /**
+     * Desaturate the color a given amount, from 0 to 100.
+     * Providing 100 will is the same as calling greyscale
+     * @param amount - valid between 1-100
+     */
+    desaturate(amount?: number): TinyColor;
+    /**
+     * Saturate the color a given amount, from 0 to 100.
+     * @param amount - valid between 1-100
+     */
+    saturate(amount?: number): TinyColor;
+    /**
+     * Completely desaturates a color into greyscale.
+     * Same as calling `desaturate(100)`
+     */
+    greyscale(): TinyColor;
+    /**
+     * Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.
+     * Values outside of this range will be wrapped into this range.
+     */
+    spin(amount: number): TinyColor;
+    /**
+     * Mix the current color a given amount with another color, from 0 to 100.
+     * 0 means no mixing (return current color).
+     */
+    mix(color: ColorInput, amount?: number): TinyColor;
+    analogous(results?: number, slices?: number): TinyColor[];
+    /**
+     * taken from https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js
+     */
+    complement(): TinyColor;
+    monochromatic(results?: number): TinyColor[];
+    splitcomplement(): TinyColor[];
+    /**
+     * Compute how the color would appear on a background
+     */
+    onBackground(background: ColorInput): TinyColor;
+    /**
+     * Alias for `polyad(3)`
+     */
+    triad(): TinyColor[];
+    /**
+     * Alias for `polyad(4)`
+     */
+    tetrad(): TinyColor[];
+    /**
+     * Get polyad colors, like (for 1, 2, 3, 4, 5, 6, 7, 8, etc...)
+     * monad, dyad, triad, tetrad, pentad, hexad, heptad, octad, etc...
+     */
+    polyad(n: number): TinyColor[];
+    /**
+     * compare color vs current color
+     */
+    equals(color?: ColorInput): boolean;
+}
+export declare function tinycolor(color?: ColorInput, opts?: Partial<TinyColorOptions>): TinyColor;