vite-plus 0.1.2 → 0.1.4

package/dist/oxlint-config.js

@@ -1,309 +0,0 @@
-// To parse this data:
-//
-//   import { Convert, OxlintConfig } from "./file";
-//
-//   const oxlintConfig = Convert.toOxlintConfig(json);
-//
-// These functions will throw an error if the JSON doesn't
-// match the expected interface, even if the JSON is valid.
-// Converts JSON strings to/from your types
-// and asserts the results of JSON.parse at runtime
-export class Convert {
-    static toOxlintConfig(json) {
-        return cast(JSON.parse(json), r('OxlintConfig'));
-    }
-    static oxlintConfigToJson(value) {
-        return JSON.stringify(uncast(value, r('OxlintConfig')), null, 2);
-    }
-}
-function invalidValue(typ, val, key, parent = '') {
-    const prettyTyp = prettyTypeName(typ);
-    const parentText = parent ? ` on ${parent}` : '';
-    const keyText = key ? ` for key "${key}"` : '';
-    throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
-}
-function prettyTypeName(typ) {
-    if (Array.isArray(typ)) {
-        if (typ.length === 2 && typ[0] === undefined) {
-            return `an optional ${prettyTypeName(typ[1])}`;
-        }
-        else {
-            return `one of [${typ
-                .map((a) => {
-                return prettyTypeName(a);
-            })
-                .join(', ')}]`;
-        }
-    }
-    else if (typeof typ === 'object' && typ.literal !== undefined) {
-        return typ.literal;
-    }
-    else {
-        return typeof typ;
-    }
-}
-function jsonToJSProps(typ) {
-    if (typ.jsonToJS === undefined) {
-        const map = {};
-        typ.props.forEach((p) => (map[p.json] = { key: p.js, typ: p.typ }));
-        typ.jsonToJS = map;
-    }
-    return typ.jsonToJS;
-}
-function jsToJSONProps(typ) {
-    if (typ.jsToJSON === undefined) {
-        const map = {};
-        typ.props.forEach((p) => (map[p.js] = { key: p.json, typ: p.typ }));
-        typ.jsToJSON = map;
-    }
-    return typ.jsToJSON;
-}
-function transform(val, typ, getProps, key = '', parent = '') {
-    function transformPrimitive(typ, val) {
-        if (typeof typ === typeof val) {
-            return val;
-        }
-        return invalidValue(typ, val, key, parent);
-    }
-    function transformUnion(typs, val) {
-        // val must validate against one typ in typs
-        const l = typs.length;
-        for (let i = 0; i < l; i++) {
-            const typ = typs[i];
-            try {
-                return transform(val, typ, getProps);
-            }
-            catch { }
-        }
-        return invalidValue(typs, val, key, parent);
-    }
-    function transformEnum(cases, val) {
-        if (cases.indexOf(val) !== -1) {
-            return val;
-        }
-        return invalidValue(cases.map((a) => {
-            return l(a);
-        }), val, key, parent);
-    }
-    function transformArray(typ, val) {
-        // val must be an array with no invalid elements
-        if (!Array.isArray(val)) {
-            return invalidValue(l('array'), val, key, parent);
-        }
-        return val.map((el) => transform(el, typ, getProps));
-    }
-    function transformDate(val) {
-        if (val === null) {
-            return null;
-        }
-        const d = new Date(val);
-        if (isNaN(d.valueOf())) {
-            return invalidValue(l('Date'), val, key, parent);
-        }
-        return d;
-    }
-    function transformObject(props, additional, val) {
-        if (val === null || typeof val !== 'object' || Array.isArray(val)) {
-            return invalidValue(l(ref || 'object'), val, key, parent);
-        }
-        const result = {};
-        Object.getOwnPropertyNames(props).forEach((key) => {
-            const prop = props[key];
-            const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
-            result[prop.key] = transform(v, prop.typ, getProps, key, ref);
-        });
-        Object.getOwnPropertyNames(val).forEach((key) => {
-            if (!Object.prototype.hasOwnProperty.call(props, key)) {
-                result[key] = transform(val[key], additional, getProps, key, ref);
-            }
-        });
-        return result;
-    }
-    if (typ === 'any') {
-        return val;
-    }
-    if (typ === null) {
-        if (val === null) {
-            return val;
-        }
-        return invalidValue(typ, val, key, parent);
-    }
-    if (typ === false) {
-        return invalidValue(typ, val, key, parent);
-    }
-    let ref = undefined;
-    while (typeof typ === 'object' && typ.ref !== undefined) {
-        ref = typ.ref;
-        typ = typeMap[typ.ref];
-    }
-    if (Array.isArray(typ)) {
-        return transformEnum(typ, val);
-    }
-    if (typeof typ === 'object') {
-        return typ.hasOwnProperty('unionMembers')
-            ? transformUnion(typ.unionMembers, val)
-            : typ.hasOwnProperty('arrayItems')
-                ? transformArray(typ.arrayItems, val)
-                : typ.hasOwnProperty('props')
-                    ? transformObject(getProps(typ), typ.additional, val)
-                    : invalidValue(typ, val, key, parent);
-    }
-    // Numbers can be parsed by Date but shouldn't be.
-    if (typ === Date && typeof val !== 'number') {
-        return transformDate(val);
-    }
-    return transformPrimitive(typ, val);
-}
-function cast(val, typ) {
-    return transform(val, typ, jsonToJSProps);
-}
-function uncast(val, typ) {
-    return transform(val, typ, jsToJSONProps);
-}
-function l(typ) {
-    return { literal: typ };
-}
-function a(typ) {
-    return { arrayItems: typ };
-}
-function u(...typs) {
-    return { unionMembers: typs };
-}
-function o(props, additional) {
-    return { props, additional };
-}
-function m(additional) {
-    return { props: [], additional };
-}
-function r(name) {
-    return { ref: name };
-}
-const typeMap = {
-    OxlintConfig: o([
-        { json: '$schema', js: '$schema', typ: u(undefined, u(null, '')) },
-        { json: 'categories', js: 'categories', typ: u(undefined, r('RuleCategories')) },
-        { json: 'env', js: 'env', typ: u(undefined, m(true)) },
-        { json: 'extends', js: 'extends', typ: u(undefined, a('')) },
-        { json: 'globals', js: 'globals', typ: u(undefined, m(r('GlobalValue'))) },
-        { json: 'ignorePatterns', js: 'ignorePatterns', typ: u(undefined, a('')) },
-        {
-            json: 'jsPlugins',
-            js: 'jsPlugins',
-            typ: u(undefined, u(a(u(r('ExternalPluginEntryClass'), '')), null)),
-        },
-        { json: 'overrides', js: 'overrides', typ: u(undefined, a(r('OxlintOverride'))) },
-        {
-            json: 'plugins',
-            js: 'plugins',
-            typ: u(undefined, u(a(r('LintPluginOptionsSchema')), null)),
-        },
-        { json: 'rules', js: 'rules', typ: u(undefined, m(u(a('any'), r('AllowWarnDenyEnum'), 0))) },
-        { json: 'settings', js: 'settings', typ: u(undefined, r('OxlintPluginSettings')) },
-    ], false),
-    RuleCategories: o([
-        { json: 'correctness', js: 'correctness', typ: u(undefined, u(r('AllowWarnDenyEnum'), 0)) },
-        { json: 'nursery', js: 'nursery', typ: u(undefined, u(r('AllowWarnDenyEnum'), 0)) },
-        { json: 'pedantic', js: 'pedantic', typ: u(undefined, u(r('AllowWarnDenyEnum'), 0)) },
-        { json: 'perf', js: 'perf', typ: u(undefined, u(r('AllowWarnDenyEnum'), 0)) },
-        { json: 'restriction', js: 'restriction', typ: u(undefined, u(r('AllowWarnDenyEnum'), 0)) },
-        { json: 'style', js: 'style', typ: u(undefined, u(r('AllowWarnDenyEnum'), 0)) },
-        { json: 'suspicious', js: 'suspicious', typ: u(undefined, u(r('AllowWarnDenyEnum'), 0)) },
-    ], false),
-    ExternalPluginEntryClass: o([
-        { json: 'name', js: 'name', typ: '' },
-        { json: 'specifier', js: 'specifier', typ: '' },
-    ], false),
-    OxlintOverride: o([
-        { json: 'env', js: 'env', typ: u(undefined, u(m(true), null)) },
-        { json: 'files', js: 'files', typ: a('') },
-        { json: 'globals', js: 'globals', typ: u(undefined, u(m(r('GlobalValue')), null)) },
-        {
-            json: 'jsPlugins',
-            js: 'jsPlugins',
-            typ: u(undefined, u(a(u(r('ExternalPluginEntryClass'), '')), null)),
-        },
-        {
-            json: 'plugins',
-            js: 'plugins',
-            typ: u(undefined, u(a(r('LintPluginOptionsSchema')), null)),
-        },
-        { json: 'rules', js: 'rules', typ: u(undefined, m(u(a('any'), r('AllowWarnDenyEnum'), 0))) },
-    ], false),
-    OxlintPluginSettings: o([
-        { json: 'jsdoc', js: 'jsdoc', typ: u(undefined, r('JSDocPluginSettings')) },
-        { json: 'jsx-a11y', js: 'jsx-a11y', typ: u(undefined, r('JSXA11YPluginSettings')) },
-        { json: 'next', js: 'next', typ: u(undefined, r('NextPluginSettings')) },
-        { json: 'react', js: 'react', typ: u(undefined, r('ReactPluginSettings')) },
-        { json: 'vitest', js: 'vitest', typ: u(undefined, r('VitestPluginSettings')) },
-    ], 'any'),
-    JSDocPluginSettings: o([
-        {
-            json: 'augmentsExtendsReplacesDocs',
-            js: 'augmentsExtendsReplacesDocs',
-            typ: u(undefined, true),
-        },
-        {
-            json: 'exemptDestructuredRootsFromChecks',
-            js: 'exemptDestructuredRootsFromChecks',
-            typ: u(undefined, true),
-        },
-        { json: 'ignoreInternal', js: 'ignoreInternal', typ: u(undefined, true) },
-        { json: 'ignorePrivate', js: 'ignorePrivate', typ: u(undefined, true) },
-        { json: 'ignoreReplacesDocs', js: 'ignoreReplacesDocs', typ: u(undefined, true) },
-        { json: 'implementsReplacesDocs', js: 'implementsReplacesDocs', typ: u(undefined, true) },
-        { json: 'overrideReplacesDocs', js: 'overrideReplacesDocs', typ: u(undefined, true) },
-        {
-            json: 'tagNamePreference',
-            js: 'tagNamePreference',
-            typ: u(undefined, m(u(true, r('TagNamePreferenceObject'), ''))),
-        },
-    ], 'any'),
-    TagNamePreferenceObject: o([
-        { json: 'message', js: 'message', typ: '' },
-        { json: 'replacement', js: 'replacement', typ: u(undefined, '') },
-    ], 'any'),
-    JSXA11YPluginSettings: o([
-        { json: 'attributes', js: 'attributes', typ: u(undefined, m(a(''))) },
-        { json: 'components', js: 'components', typ: u(undefined, m('')) },
-        { json: 'polymorphicPropName', js: 'polymorphicPropName', typ: u(undefined, u(null, '')) },
-    ], 'any'),
-    NextPluginSettings: o([{ json: 'rootDir', js: 'rootDir', typ: u(undefined, u(a(''), '')) }], 'any'),
-    ReactPluginSettings: o([
-        {
-            json: 'formComponents',
-            js: 'formComponents',
-            typ: u(undefined, a(u(r('CustomComponentObject'), ''))),
-        },
-        {
-            json: 'linkComponents',
-            js: 'linkComponents',
-            typ: u(undefined, a(u(r('CustomComponentObject'), ''))),
-        },
-        { json: 'version', js: 'version', typ: u(undefined, u(null, '')) },
-    ], 'any'),
-    CustomComponentObject: o([
-        { json: 'attribute', js: 'attribute', typ: u(undefined, '') },
-        { json: 'name', js: 'name', typ: '' },
-        { json: 'attributes', js: 'attributes', typ: u(undefined, a('')) },
-    ], 'any'),
-    VitestPluginSettings: o([{ json: 'typecheck', js: 'typecheck', typ: u(undefined, true) }], 'any'),
-    AllowWarnDenyEnum: ['allow', 'deny', 'error', 'off', 'warn'],
-    GlobalValue: ['off', 'readonly', 'writable'],
-    LintPluginOptionsSchema: [
-        'eslint',
-        'import',
-        'jest',
-        'jsdoc',
-        'jsx-a11y',
-        'nextjs',
-        'node',
-        'oxc',
-        'promise',
-        'react',
-        'react-perf',
-        'typescript',
-        'unicorn',
-        'vitest',
-        'vue',
-    ],
-};