gant-core 0.1.40 → 0.1.42

package/lib/cli/index.js

@@ -66794,7 +66794,7 @@ const createCwdConfig = (cwd, name, vue) => {
 };
 
 var name = "gant-core";
-var version = "0.1.39";
+var version = "0.1.42";
 var description = "";
 var main = "lib/index.js";
 var bin = {

package/lib/index.d.ts

@@ -7,6 +7,7 @@ export * from 'axios';
 import * as mitt from 'mitt';
 import * as i18next from 'i18next';
 import { InitOptions, Callback } from 'i18next';
+export * from '@ctrl/tinycolor';
 
 declare const PresetColors: readonly ["blue", "purple", "cyan", "green", "magenta", "pink", "red", "orange", "yellow", "volcano", "geekblue", "lime", "gold"];
 type PresetColorKey = (typeof PresetColors)[number];
@@ -1989,6 +1990,7 @@ interface GlobalOptions {
     menuData?: ServerMenuData | ((res: UserAggregateInfo) => ServerMenuData);
     loginSuccessCallback?: () => void;
     ssoCallback?: () => boolean;
+    websocket?: boolean;
 }
 
 declare const MENU_HISTORY_UPDATE = "MENU_HISTORY_UPDATE";

package/lib/index.js

@@ -1193,7 +1193,7 @@ class GlobalStoreClass {
         this.menuStore.init(isEmpty(localeMenus) ? startMenus : localeMenus, currentUser.id);
     };
     init = async (options) => {
-        const { base = "/", menuData, loginSuccessCallback, ssoCallback } = options;
+        const { base = "/", menuData, loginSuccessCallback, ssoCallback, websocket: _startwebsocket = true } = options;
         this.loginStore.init(options?.loginConfig, base, ssoCallback);
         try {
             //检查token
@@ -1205,7 +1205,8 @@ class GlobalStoreClass {
                 await codeListStoreInstance.findAllCodeList();
                 await parameterStoreInstance.findAllParameters();
                 //websocket注册
-                websocket.init(this.userStore.currentUser.userLoginName);
+                if (_startwebsocket)
+                    websocket.init(this.userStore.currentUser.userLoginName);
                 await loginSuccessCallback?.();
                 return true;
             }
@@ -3979,6 +3980,19 @@ function rgbaToHex(r, g, b, a, allow4Char) {
     }
     return hex.join('');
 }
+/**
+ * Converts an RGBA color to an ARGB Hex8 string
+ * Rarely used, but required for "toFilter()"
+ */
+function rgbaToArgbHex(r, g, b, a) {
+    var hex = [
+        pad2(convertDecimalToHex(a)),
+        pad2(Math.round(r).toString(16)),
+        pad2(Math.round(g).toString(16)),
+        pad2(Math.round(b).toString(16)),
+    ];
+    return hex.join('');
+}
 /** Converts a decimal to a hex value */
 function convertDecimalToHex(d) {
     return Math.round(parseFloat(d) * 255).toString(16);
@@ -4832,6 +4846,405 @@ var TinyColor = /** @class */ (function () {
     };
     return TinyColor;
 }());
+// kept for backwards compatability with v1
+function tinycolor(color, opts) {
+    if (color === void 0) { color = ''; }
+    if (opts === void 0) { opts = {}; }
+    return new TinyColor(color, opts);
+}
+
+// Readability Functions
+// ---------------------
+// <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)
+/**
+ * AKA `contrast`
+ *
+ * Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)
+ */
+function readability(color1, color2) {
+    var c1 = new TinyColor(color1);
+    var c2 = new TinyColor(color2);
+    return ((Math.max(c1.getLuminance(), c2.getLuminance()) + 0.05) /
+        (Math.min(c1.getLuminance(), c2.getLuminance()) + 0.05));
+}
+/**
+ * Ensure that foreground and background color combinations meet WCAG2 guidelines.
+ * The third argument is an object.
+ *      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';
+ *      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.
+ * If the entire object is absent, isReadable defaults to {level:"AA",size:"small"}.
+ *
+ * Example
+ * ```ts
+ * new TinyColor().isReadable('#000', '#111') => false
+ * new TinyColor().isReadable('#000', '#111', { level: 'AA', size: 'large' }) => false
+ * ```
+ */
+function isReadable(color1, color2, wcag2) {
+    var _a, _b;
+    if (wcag2 === void 0) { wcag2 = { level: 'AA', size: 'small' }; }
+    var readabilityLevel = readability(color1, color2);
+    switch (((_a = wcag2.level) !== null && _a !== void 0 ? _a : 'AA') + ((_b = wcag2.size) !== null && _b !== void 0 ? _b : 'small')) {
+        case 'AAsmall':
+        case 'AAAlarge':
+            return readabilityLevel >= 4.5;
+        case 'AAlarge':
+            return readabilityLevel >= 3;
+        case 'AAAsmall':
+            return readabilityLevel >= 7;
+        default:
+            return false;
+    }
+}
+/**
+ * Given a base color and a list of possible foreground or background
+ * colors for that base, returns the most readable color.
+ * Optionally returns Black or White if the most readable color is unreadable.
+ *
+ * @param baseColor - the base color.
+ * @param colorList - array of colors to pick the most readable one from.
+ * @param args - and object with extra arguments
+ *
+ * Example
+ * ```ts
+ * new TinyColor().mostReadable('#123', ['#124", "#125'], { includeFallbackColors: false }).toHexString(); // "#112255"
+ * new TinyColor().mostReadable('#123', ['#124", "#125'],{ includeFallbackColors: true }).toHexString();  // "#ffffff"
+ * new TinyColor().mostReadable('#a8015a', ["#faf3f3"], { includeFallbackColors:true, level: 'AAA', size: 'large' }).toHexString(); // "#faf3f3"
+ * new TinyColor().mostReadable('#a8015a', ["#faf3f3"], { includeFallbackColors:true, level: 'AAA', size: 'small' }).toHexString(); // "#ffffff"
+ * ```
+ */
+function mostReadable(baseColor, colorList, args) {
+    if (args === void 0) { args = { includeFallbackColors: false, level: 'AA', size: 'small' }; }
+    var bestColor = null;
+    var bestScore = 0;
+    var includeFallbackColors = args.includeFallbackColors, level = args.level, size = args.size;
+    for (var _i = 0, colorList_1 = colorList; _i < colorList_1.length; _i++) {
+        var color = colorList_1[_i];
+        var score = readability(baseColor, color);
+        if (score > bestScore) {
+            bestScore = score;
+            bestColor = new TinyColor(color);
+        }
+    }
+    if (isReadable(baseColor, bestColor, { level: level, size: size }) || !includeFallbackColors) {
+        return bestColor;
+    }
+    args.includeFallbackColors = false;
+    return mostReadable(baseColor, ['#fff', '#000'], args);
+}
+
+/**
+ * Returns the color represented as a Microsoft filter for use in old versions of IE.
+ */
+function toMsFilter(firstColor, secondColor) {
+    var color = new TinyColor(firstColor);
+    var hex8String = '#' + rgbaToArgbHex(color.r, color.g, color.b, color.a);
+    var secondHex8String = hex8String;
+    var gradientType = color.gradientType ? 'GradientType = 1, ' : '';
+    if (secondColor) {
+        var s = new TinyColor(secondColor);
+        secondHex8String = '#' + rgbaToArgbHex(s.r, s.g, s.b, s.a);
+    }
+    return "progid:DXImageTransform.Microsoft.gradient(".concat(gradientType, "startColorstr=").concat(hex8String, ",endColorstr=").concat(secondHex8String, ")");
+}
+
+/**
+ * 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: convertToPercentage(ratio.r),
+        g: convertToPercentage(ratio.g),
+        b: convertToPercentage(ratio.b),
+    };
+    if (ratio.a !== undefined) {
+        newColor.a = Number(ratio.a);
+    }
+    return new TinyColor(newColor, opts);
+}
+/** old random function */
+function legacyRandom() {
+    return new TinyColor({
+        r: Math.random(),
+        g: Math.random(),
+        b: Math.random(),
+    });
+}
+
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
+// randomColor by David Merfield under the CC0 license
+// https://github.com/davidmerfield/randomColor/
+function random(options) {
+    if (options === void 0) { options = {}; }
+    // Check if we need to generate multiple colors
+    if (options.count !== undefined &&
+        options.count !== null) {
+        var totalColors = options.count;
+        var colors = [];
+        options.count = undefined;
+        while (totalColors > colors.length) {
+            // Since we're generating multiple colors,
+            // incremement the seed. Otherwise we'd just
+            // generate the same color each time...
+            options.count = null;
+            if (options.seed) {
+                options.seed += 1;
+            }
+            colors.push(random(options));
+        }
+        options.count = totalColors;
+        return colors;
+    }
+    // First we pick a hue (H)
+    var h = pickHue(options.hue, options.seed);
+    // Then use H to determine saturation (S)
+    var s = pickSaturation(h, options);
+    // Then use S and H to determine brightness (B).
+    var v = pickBrightness(h, s, options);
+    var res = { h: h, s: s, v: v };
+    if (options.alpha !== undefined) {
+        res.a = options.alpha;
+    }
+    // Then we return the HSB color in the desired format
+    return new TinyColor(res);
+}
+function pickHue(hue, seed) {
+    var hueRange = getHueRange(hue);
+    var res = randomWithin(hueRange, seed);
+    // Instead of storing red as two seperate ranges,
+    // we group them, using negative numbers
+    if (res < 0) {
+        res = 360 + res;
+    }
+    return res;
+}
+function pickSaturation(hue, options) {
+    if (options.hue === 'monochrome') {
+        return 0;
+    }
+    if (options.luminosity === 'random') {
+        return randomWithin([0, 100], options.seed);
+    }
+    var saturationRange = getColorInfo(hue).saturationRange;
+    var sMin = saturationRange[0];
+    var sMax = saturationRange[1];
+    switch (options.luminosity) {
+        case 'bright':
+            sMin = 55;
+            break;
+        case 'dark':
+            sMin = sMax - 10;
+            break;
+        case 'light':
+            sMax = 55;
+            break;
+    }
+    return randomWithin([sMin, sMax], options.seed);
+}
+function pickBrightness(H, S, options) {
+    var bMin = getMinimumBrightness(H, S);
+    var bMax = 100;
+    switch (options.luminosity) {
+        case 'dark':
+            bMax = bMin + 20;
+            break;
+        case 'light':
+            bMin = (bMax + bMin) / 2;
+            break;
+        case 'random':
+            bMin = 0;
+            bMax = 100;
+            break;
+    }
+    return randomWithin([bMin, bMax], options.seed);
+}
+function getMinimumBrightness(H, S) {
+    var lowerBounds = getColorInfo(H).lowerBounds;
+    for (var i = 0; i < lowerBounds.length - 1; i++) {
+        var s1 = lowerBounds[i][0];
+        var v1 = lowerBounds[i][1];
+        var s2 = lowerBounds[i + 1][0];
+        var v2 = lowerBounds[i + 1][1];
+        if (S >= s1 && S <= s2) {
+            var m = (v2 - v1) / (s2 - s1);
+            var b = v1 - m * s1;
+            return m * S + b;
+        }
+    }
+    return 0;
+}
+function getHueRange(colorInput) {
+    var num = parseInt(colorInput, 10);
+    if (!Number.isNaN(num) && num < 360 && num > 0) {
+        return [num, num];
+    }
+    if (typeof colorInput === 'string') {
+        var namedColor = bounds.find(function (n) { return n.name === colorInput; });
+        if (namedColor) {
+            var color = defineColor(namedColor);
+            if (color.hueRange) {
+                return color.hueRange;
+            }
+        }
+        var parsed = new TinyColor(colorInput);
+        if (parsed.isValid) {
+            var hue = parsed.toHsv().h;
+            return [hue, hue];
+        }
+    }
+    return [0, 360];
+}
+function getColorInfo(hue) {
+    // Maps red colors to make picking hue easier
+    if (hue >= 334 && hue <= 360) {
+        hue -= 360;
+    }
+    for (var _i = 0, bounds_1 = bounds; _i < bounds_1.length; _i++) {
+        var bound = bounds_1[_i];
+        var color = defineColor(bound);
+        if (color.hueRange && hue >= color.hueRange[0] && hue <= color.hueRange[1]) {
+            return color;
+        }
+    }
+    throw Error('Color not found');
+}
+function randomWithin(range, seed) {
+    if (seed === undefined) {
+        return Math.floor(range[0] + Math.random() * (range[1] + 1 - range[0]));
+    }
+    // Seeded random algorithm from http://indiegamr.com/generate-repeatable-random-numbers-in-js/
+    var max = range[1] || 1;
+    var min = range[0] || 0;
+    seed = (seed * 9301 + 49297) % 233280;
+    var rnd = seed / 233280.0;
+    return Math.floor(min + rnd * (max - min));
+}
+function defineColor(bound) {
+    var sMin = bound.lowerBounds[0][0];
+    var sMax = bound.lowerBounds[bound.lowerBounds.length - 1][0];
+    var bMin = bound.lowerBounds[bound.lowerBounds.length - 1][1];
+    var bMax = bound.lowerBounds[0][1];
+    return {
+        name: bound.name,
+        hueRange: bound.hueRange,
+        lowerBounds: bound.lowerBounds,
+        saturationRange: [sMin, sMax],
+        brightnessRange: [bMin, bMax],
+    };
+}
+/**
+ * @hidden
+ */
+var bounds = [
+    {
+        name: 'monochrome',
+        hueRange: null,
+        lowerBounds: [
+            [0, 0],
+            [100, 0],
+        ],
+    },
+    {
+        name: 'red',
+        hueRange: [-26, 18],
+        lowerBounds: [
+            [20, 100],
+            [30, 92],
+            [40, 89],
+            [50, 85],
+            [60, 78],
+            [70, 70],
+            [80, 60],
+            [90, 55],
+            [100, 50],
+        ],
+    },
+    {
+        name: 'orange',
+        hueRange: [19, 46],
+        lowerBounds: [
+            [20, 100],
+            [30, 93],
+            [40, 88],
+            [50, 86],
+            [60, 85],
+            [70, 70],
+            [100, 70],
+        ],
+    },
+    {
+        name: 'yellow',
+        hueRange: [47, 62],
+        lowerBounds: [
+            [25, 100],
+            [40, 94],
+            [50, 89],
+            [60, 86],
+            [70, 84],
+            [80, 82],
+            [90, 80],
+            [100, 75],
+        ],
+    },
+    {
+        name: 'green',
+        hueRange: [63, 178],
+        lowerBounds: [
+            [30, 100],
+            [40, 90],
+            [50, 85],
+            [60, 81],
+            [70, 74],
+            [80, 64],
+            [90, 50],
+            [100, 40],
+        ],
+    },
+    {
+        name: 'blue',
+        hueRange: [179, 257],
+        lowerBounds: [
+            [20, 100],
+            [30, 86],
+            [40, 80],
+            [50, 74],
+            [60, 60],
+            [70, 52],
+            [80, 44],
+            [90, 39],
+            [100, 35],
+        ],
+    },
+    {
+        name: 'purple',
+        hueRange: [258, 282],
+        lowerBounds: [
+            [20, 100],
+            [30, 87],
+            [40, 79],
+            [50, 70],
+            [60, 65],
+            [70, 59],
+            [80, 52],
+            [90, 45],
+            [100, 42],
+        ],
+    },
+    {
+        name: 'pink',
+        hueRange: [283, 334],
+        lowerBounds: [
+            [20, 100],
+            [30, 90],
+            [40, 86],
+            [60, 84],
+            [80, 80],
+            [90, 75],
+            [100, 73],
+        ],
+    },
+];
 
 var hueStep = 2; // 色相阶梯
 var saturationStep = 0.16; // 饱和度阶梯，浅色部分
@@ -5961,5 +6374,5 @@ var main = async ({ microServiceMap, dynamicLangCallback, ...globalOptions }) =>
     return res;
 };
 
-export { MENU_BREADCRUMBS_UPDATE, MENU_HISTORY_UPDATE, PROGRESS_UPDEDATE, PresetColors, WS_CONTENT_CLOSE, WS_CONTENT_ERROR, WS_CONTENT_SUCCESS, codeListStore, derivative$1 as compactAlgorithm, index as companydataStore, derivative$2 as darkAlgorithm, derivative$3 as defaultAlgorithm, emitter, expireCache, formatToken as formatAliasToken, getAliasToken, getAlphaColor$1 as getAlphaColor, getAntdLocaleKey, getBackgroundColor, getDarkenSolidColor, getLightenSolidColor, getLocaleKey, getRoutes, getTokenCssVar, getTraceId, globalStore, main as init, initDynamicLang, lighten, loginStore, menuStore, parameterStore, Progress as progress, request, requestInstance, seedToken as seed, setLocaleKey, storage as storageStore, token, tr, useRequestHeader, useRequestMicroSevices, userStore, websocket };
+export { MENU_BREADCRUMBS_UPDATE, MENU_HISTORY_UPDATE, PROGRESS_UPDEDATE, PresetColors, TinyColor, WS_CONTENT_CLOSE, WS_CONTENT_ERROR, WS_CONTENT_SUCCESS, bounds, codeListStore, derivative$1 as compactAlgorithm, index as companydataStore, convertDecimalToHex, convertHexToDecimal, derivative$2 as darkAlgorithm, derivative$3 as defaultAlgorithm, emitter, expireCache, formatToken as formatAliasToken, fromRatio, getAliasToken, getAlphaColor$1 as getAlphaColor, getAntdLocaleKey, getBackgroundColor, getDarkenSolidColor, getLightenSolidColor, getLocaleKey, getRoutes, getTokenCssVar, getTraceId, globalStore, hslToRgb, hsvToRgb, main as init, initDynamicLang, inputToRGB, isReadable, isValidCSSUnit, legacyRandom, lighten, loginStore, menuStore, mostReadable, names, numberInputToObject, parameterStore, parseIntFromHex, Progress as progress, random, readability, request, requestInstance, rgbToHex, rgbToHsl, rgbToHsv, rgbToRgb, rgbaToArgbHex, rgbaToHex, seedToken as seed, setLocaleKey, storage as storageStore, stringInputToObject, tinycolor, toMsFilter, token, tr, useRequestHeader, useRequestMicroSevices, userStore, websocket };
 //# sourceMappingURL=index.js.map