@dovetail-v2/refine 0.0.63-alpha.1 → 0.0.63-hotfix.1

package/lib/src/utils/schema.js

@@ -1,117 +0,0 @@
-import { pick } from 'lodash';
-export function generateValueFromSchema(schema, options) {
-    const { generateValue } = options;
-    if (!schema) {
-        return {};
-    }
-    switch (true) {
-        case schema.type === 'string' && 'enum' in schema && Boolean(schema.enum?.length):
-            return generateValue?.(schema) || schema.enum?.[0];
-        case schema.type === 'string':
-            return generateValue?.(schema) || '';
-        case schema.type === 'boolean':
-            return generateValue?.(schema) || false;
-        case schema.type === 'array':
-            if (!schema.minItems ||
-                !schema.items ||
-                typeof schema.items === 'boolean' ||
-                Array.isArray(schema.items)) {
-                return generateValue?.(schema) || [];
-            }
-            return new Array(schema.minItems).fill(generateValueFromSchema(schema.items, options));
-        case schema.type === 'number':
-        case schema.type === 'integer':
-            return generateValue?.(schema) || 0;
-        case schema.type === 'object': {
-            const obj = {};
-            for (const key in schema.properties) {
-                obj[key] = generateValueFromSchema(schema.properties[key], options);
-            }
-            return obj;
-        }
-        case Array.isArray(schema.type) && 'anyOf' in schema && Boolean(schema.anyOf?.length):
-        case Array.isArray(schema.type) &&
-            'oneOf' in schema &&
-            Boolean(schema.oneOf?.length):
-            {
-                const subSchema = (schema.anyOf || schema.oneOf)?.[0];
-                return generateValueFromSchema(subSchema, options);
-            }
-        case 'allOf' in schema && Boolean(schema.allOf?.length):
-            return generateValueFromSchema(schema.allOf?.[0], options);
-        default:
-            return undefined;
-    }
-}
-export function generateSchemaTypeValue(schema) {
-    return generateValueFromSchema(schema, {
-        generateValue(schema) {
-            if (schema.type === 'array' && schema.items) {
-                return generateSchemaTypeValue(schema.items);
-            }
-            else {
-                return schema.type;
-            }
-        },
-    });
-}
-export function resolveRef(schema, schemas, options) {
-    const { prune } = options;
-    if (schema.$ref) {
-        const refKey = schema.$ref.replace('#/components/schemas/', '');
-        Object.assign(schema, schemas[refKey]);
-        if (prune.metadata &&
-            [
-                'io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta',
-                'io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta',
-            ].some(k => refKey.includes(k)) &&
-            schema.properties) {
-            schema.properties = pick(schema.properties, [
-                'name',
-                'namespace',
-                'annotations',
-                'labels',
-            ]);
-        }
-        delete schema.$ref;
-    }
-    for (const schemaKey in schema) {
-        if (prune.xProperty &&
-            schemaKey.startsWith('x-') &&
-            schemaKey !== 'x-kubernetes-group-version-kind') {
-            delete schema[schemaKey];
-        }
-    }
-    switch (true) {
-        case schema.type === 'array':
-            if (Array.isArray(schema.items)) {
-                schema.items.forEach(item => resolveRef(item, schemas, options));
-            }
-            else if (typeof schema.items === 'object') {
-                resolveRef(schema.items, schemas, options);
-            }
-            break;
-        case schema.type === 'object':
-            for (const key in schema.properties) {
-                const subSchema = schema.properties[key];
-                if (prune.optional && !schema.required?.includes(key)) {
-                    delete schema.properties[key];
-                }
-                if (prune.fields.includes(key)) {
-                    delete schema.properties[key];
-                }
-                resolveRef(subSchema, schemas, options);
-            }
-            if (schema.additionalProperties) {
-                resolveRef(schema.additionalProperties, schemas, options);
-            }
-            break;
-        case !!(schema.allOf && schema.allOf[0]):
-            resolveRef(schema.allOf?.[0], schemas, options);
-        default:
-    }
-    if (prune.description) {
-        delete schema.description;
-    }
-    return schema;
-}

package/lib/src/utils/selector.js

@@ -1,12 +0,0 @@
-export function matchSelector(pod, selector) {
-    let match = true;
-    // TODO: support complete selector match strategy
-    // https://github.com/rancher/dashboard/blob/master/shell/utils/selector.js#L166
-    for (const key in selector.matchLabels) {
-        if (!pod.metadata?.labels?.[key] ||
-            pod.metadata.labels?.[key] !== selector.matchLabels[key]) {
-            match = false;
-        }
-    }
-    return match;
-}

package/lib/src/utils/string.js

@@ -1,6 +0,0 @@
-export function shortenedImage(image) {
-    return (image || '')
-        .replace(/^(index\.)?docker.io\/(library\/)?/, '')
-        .replace(/:latest$/, '')
-        .replace(/^(.*@sha256:)([0-9a-f]{8})[0-9a-f]+$/i, '$1$2…');
-}

package/lib/src/utils/time.js

@@ -1,46 +0,0 @@
-export function getSecondsDiff(startDate, endDate) {
-    return Math.round(Math.abs(Date.parse(endDate) - Date.parse(startDate)) / 1000);
-}
-export function elapsedTime(seconds, i18nMap) {
-    const { min, sec, hr, day } = i18nMap;
-    if (!seconds) {
-        return {};
-    }
-    if (seconds < 120) {
-        return {
-            diff: 1,
-            label: `${seconds} ${sec}`,
-        };
-    }
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 10) {
-        return {
-            diff: 1,
-            label: `${minutes} ${min} ${seconds - minutes * 60} ${sec}`,
-        };
-    }
-    const hours = Math.floor(seconds / 3600);
-    if (hours < 3) {
-        return {
-            diff: 60,
-            label: `${minutes} ${min}`,
-        };
-    }
-    const days = Math.floor(seconds / (3600 * 24));
-    if (days > 1) {
-        return {
-            diff: 60,
-            label: `${days} ${day} ${hours - days * 24} ${hr}`,
-        };
-    }
-    if (hours > 7) {
-        return {
-            diff: 60,
-            label: `${hours} ${hr}`,
-        };
-    }
-    return {
-        diff: 60,
-        label: `${hours} ${hr} ${minutes - hours * 60} ${min}`,
-    };
-}

package/lib/src/utils/unit.js

@@ -1,69 +0,0 @@
-const UNITS = ['', 'K', 'M', 'G', 'T', 'P'];
-const FRACTIONAL = ['', 'm', 'u', 'n', 'p', 'f']; // milli micro nano pico femto
-export function formatSi(inValue, options) {
-    const { increment = 1000, suffix = null, firstSuffix = null, startingExponent = 0, minExponent = 0, maxPrecision = 2, atLeastOne = true, } = options || {};
-    let val = inValue;
-    let exp = startingExponent;
-    while ((val >= increment && exp + 1 < UNITS.length) || exp < minExponent) {
-        val = val / increment;
-        exp++;
-    }
-    let out = 0;
-    if (val < 10 && maxPrecision >= 2) {
-        out = Math.round(val * 100) / 100;
-    }
-    else if (val < 100 && maxPrecision >= 1) {
-        out = Math.round(val * 10) / 10;
-    }
-    else {
-        out = Math.round(val);
-    }
-    if (atLeastOne && out === 0) {
-        out = 1;
-    }
-    let outStr = String(out);
-    if (exp === 0 && firstSuffix !== null) {
-        outStr += `${firstSuffix}`;
-    }
-    else {
-        outStr += `${UNITS[exp]}${suffix}` || '';
-    }
-    return outStr;
-}
-export function parseSi(inValue, increment = null, allowFractional = true) {
-    if (!inValue || typeof inValue !== 'string' || !inValue.length) {
-        return NaN;
-    }
-    inValue = inValue.replace(/,/g, '');
-    // eslint-disable-next-line prefer-const
-    let [, valStr, unit, incStr] = inValue.match(/^([0-9.-]+)\s*([^0-9.-]?)([^0-9.-]?)/) || [];
-    const val = parseFloat(valStr);
-    if (!unit) {
-        return val;
-    }
-    // micro "mu" symbol -> u
-    if (unit.charCodeAt(0) === 181) {
-        unit = 'u';
-    }
-    const divide = FRACTIONAL.includes(unit);
-    const multiply = UNITS.includes(unit.toUpperCase());
-    if (increment === null) {
-        // Automatically handle 1 KB = 1000B, 1 KiB = 1024B if no increment set
-        if ((multiply || divide) && incStr === 'i') {
-            increment = 1024;
-        }
-        else {
-            increment = 1000;
-        }
-    }
-    if (divide && allowFractional) {
-        const exp = FRACTIONAL.indexOf(unit);
-        return val / Math.pow(increment, exp);
-    }
-    if (multiply) {
-        const exp = UNITS.indexOf(unit.toUpperCase());
-        return val * Math.pow(increment, exp);
-    }
-    // Unrecognized unit character
-    return val;
-}

package/lib/src/utils/yaml.js

@@ -1,44 +0,0 @@
-import yaml from 'js-yaml';
-import { isObject } from 'lodash-es';
-import { generateSchemaTypeValue } from './schema';
-export function generateYamlBySchema(defaultValue, schema) {
-    const typeObject = generateSchemaTypeValue(schema);
-    function makeAnnotations(obj, key) {
-        const result = {};
-        if (isObject(obj[key])) {
-            result[`#${key}`] = {};
-            Object.keys(obj[key]).forEach(prop => {
-                result[`#${key}`] = {
-                    ...result[`#${key}`],
-                    ...makeAnnotations(obj[key], prop),
-                };
-            });
-        }
-        else {
-            result[`#${key}`] = obj[key];
-        }
-        return result;
-    }
-    function merge(obj1, obj2, merged = {}) {
-        for (const key in obj1) {
-            merged[key] = obj1[key];
-        }
-        for (const key in obj2) {
-            if (key in obj1) {
-                if (isObject(obj2[key]) && isObject(obj1[key])) {
-                    merged[key] = merge(obj1[key], obj2[key]);
-                }
-            }
-            else {
-                merged = {
-                    ...merged,
-                    ...makeAnnotations(obj2, key),
-                };
-            }
-        }
-        return merged;
-    }
-    const merged = merge(defaultValue, typeObject);
-    const content = yaml.dump(merged);
-    return content.replace(/(')(#.+?)(')/g, '$2').replace(/( +)(#)/g, '$2$1');
-}

package/lib/vite.config.js

@@ -1,60 +0,0 @@
-import path from 'path';
-import linaria from '@linaria/vite';
-import react from '@vitejs/plugin-react';
-import { defineConfig } from 'vite';
-import commonjs from 'vite-plugin-commonjs';
-// import { getProxyConfig } from './tools/proxy-k8s';
-export default defineConfig({
-    plugins: [commonjs(), react(), linaria()],
-    server: {
-        host: '0.0.0.0',
-        proxy: {
-            // '/proxy-k8s': getProxyConfig(),
-            '/api': {
-                target: process.env.API_HOST || 'http://192.168.28.26',
-                ws: true,
-                headers: {
-                    'x-skip-auth-verify': 'true',
-                },
-            },
-        },
-    },
-    optimizeDeps: {
-        exclude: ['monaco-yaml/yaml.worker.js']
-    },
-    build: {
-        minify: false,
-        lib: {
-            entry: path.resolve(__dirname, 'src/index.ts'),
-            name: 'dovetail',
-        },
-        rollupOptions: {
-            external: [
-                '@cloudtower/eagle',
-                '@cloudtower/icons-react',
-                '@refinedev/core',
-                '@refinedev/inferencer',
-                'antd',
-                'i18next',
-                'ky',
-                'lodash-es',
-                'mitt',
-                'qs',
-                'react',
-                'react-dom',
-                'react-router-dom',
-                'sunflower-antd',
-                'monaco-editor',
-                'monaco-yaml',
-                'js-yaml',
-                'k8s-api-provider',
-            ],
-        },
-    },
-    resolve: {
-        preserveSymlinks: true,
-        alias: {
-            src: path.resolve(__dirname, 'src'),
-        },
-    },
-});