@bleedingdev/modern-js-code-tools 3.5.0-ultramodern.30 → 3.5.0-ultramodern.32

package/dist/cjs/oxlint-plugin/ast.cjs

@@ -0,0 +1,187 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    asStringArray: ()=>asStringArray,
+    expressionStringValue: ()=>expressionStringValue,
+    getCallExpressionName: ()=>getCallExpressionName,
+    getIgnorePattern: ()=>getIgnorePattern,
+    getJsxElementName: ()=>getJsxElementName,
+    getLine: ()=>getLine,
+    getNodeName: ()=>getNodeName,
+    getSourceText: ()=>getSourceText,
+    getStringLiteralValue: ()=>getStringLiteralValue,
+    getTemplateLiteralValue: ()=>getTemplateLiteralValue,
+    hasAllowedElementAncestor: ()=>hasAllowedElementAncestor,
+    hasIgnoreComment: ()=>hasIgnoreComment,
+    hasLetters: ()=>hasLetters,
+    isApiEntryFile: ()=>isApiEntryFile,
+    isApiSourceFile: ()=>isApiSourceFile,
+    isForbiddenGeneratedEffectPath: ()=>isForbiddenGeneratedEffectPath,
+    isRecord: ()=>isRecord,
+    isSharedApiContractFile: ()=>isSharedApiContractFile,
+    normalizeFilename: ()=>normalizeFilename,
+    normalizeVisibleText: ()=>normalizeVisibleText,
+    reportMissingProgramPattern: ()=>reportMissingProgramPattern,
+    reportProgramPattern: ()=>reportProgramPattern,
+    reportVisibleText: ()=>reportVisibleText
+});
+const external_options_cjs_namespaceObject = require("./options.cjs");
+const isRecord = (value)=>Boolean(value) && 'object' == typeof value && !Array.isArray(value);
+const asStringArray = (value, fallback)=>Array.isArray(value) && value.every((item)=>'string' == typeof item) ? value : fallback;
+const normalizeVisibleText = (value)=>value.replaceAll(/\s+/gu, ' ').trim();
+const hasLetters = (value)=>external_options_cjs_namespaceObject.LETTER_PATTERN.test(value);
+const getNodeName = (node)=>{
+    if (!node) return;
+    if ('string' == typeof node.name) return node.name;
+    if ('JSXIdentifier' === node.type && isRecord(node.name) && 'string' == typeof node.name.name) return node.name.name;
+    if ('JSXIdentifier' === node.type && 'string' == typeof node.name) return node.name;
+    if (('JSXMemberExpression' === node.type || 'MemberExpression' === node.type) && isRecord(node.property) && true !== node.computed) {
+        const objectName = getNodeName(node.object);
+        const propertyName = getNodeName(node.property);
+        return objectName && propertyName ? `${objectName}.${propertyName}` : propertyName;
+    }
+};
+const getJsxElementName = (node)=>{
+    if (node?.type !== 'JSXElement') return;
+    return getNodeName(node.openingElement?.name);
+};
+const hasAllowedElementAncestor = (node, allowedElements)=>{
+    let current = node;
+    while(current){
+        const elementName = getJsxElementName(current);
+        if (elementName && allowedElements.has(elementName)) return true;
+        current = current.parent;
+    }
+    return false;
+};
+const getTemplateLiteralValue = (node)=>{
+    if ('TemplateLiteral' !== node.type || (node.expressions?.length ?? 0) > 0) return;
+    const quasi = node.quasis?.[0];
+    if (!isRecord(quasi?.value)) return;
+    const cooked = quasi.value.cooked;
+    const raw = quasi.value.raw;
+    return 'string' == typeof cooked ? cooked : 'string' == typeof raw ? raw : void 0;
+};
+const getStringLiteralValue = (node)=>{
+    if (!node) return;
+    if (('Literal' === node.type || 'StringLiteral' === node.type) && 'string' == typeof node.value) return node.value;
+    return getTemplateLiteralValue(node);
+};
+const expressionStringValue = (node)=>getStringLiteralValue(node?.type === 'JSXExpressionContainer' ? node.expression : node);
+const getLine = (node)=>node.loc?.start?.line;
+const hasIgnoreComment = (node, context, pattern)=>{
+    const sourceCode = context.getSourceCode?.();
+    const nodeLine = getLine(node);
+    if (!sourceCode?.getAllComments || void 0 === nodeLine) return false;
+    return sourceCode.getAllComments().some((comment)=>{
+        const commentValue = String(comment.value ?? '');
+        if (!pattern.test(commentValue)) return false;
+        const startLine = comment.loc?.start?.line;
+        const endLine = comment.loc?.end?.line ?? startLine;
+        return void 0 !== startLine && void 0 !== endLine && startLine <= nodeLine + 1 && endLine >= nodeLine - 1;
+    });
+};
+const getIgnorePattern = (options)=>new RegExp(options.ignoreCommentPattern, 'u');
+const reportVisibleText = (context, node, text)=>{
+    context.report({
+        node,
+        message: `Move user-visible JSX text to locale resources: ${JSON.stringify(text)}`
+    });
+};
+const getSourceText = (context, node)=>context.getSourceCode?.().getText?.(node) ?? context.getSourceCode?.().text ?? '';
+const normalizeFilename = (filePath)=>(filePath ?? '').replaceAll('\\', '/');
+const isApiSourceFile = (filePath)=>external_options_cjs_namespaceObject.API_SOURCE_FILE_PATTERN.test(normalizeFilename(filePath));
+const isForbiddenGeneratedEffectPath = (filePath)=>external_options_cjs_namespaceObject.FORBIDDEN_GENERATED_EFFECT_PATH_PATTERN.test(normalizeFilename(filePath));
+const isApiEntryFile = (filePath)=>external_options_cjs_namespaceObject.API_ENTRY_PATTERN.test(normalizeFilename(filePath));
+const isSharedApiContractFile = (filePath)=>external_options_cjs_namespaceObject.SHARED_API_CONTRACT_PATTERN.test(normalizeFilename(filePath));
+const getCallExpressionName = (node)=>getNodeName(node);
+const reportProgramPattern = (context, node, source, pattern, message)=>{
+    if (pattern.test(source)) context.report({
+        node,
+        message
+    });
+};
+const reportMissingProgramPattern = (context, node, source, pattern, message)=>{
+    if (!pattern.test(source)) context.report({
+        node,
+        message
+    });
+};
+exports.asStringArray = __webpack_exports__.asStringArray;
+exports.expressionStringValue = __webpack_exports__.expressionStringValue;
+exports.getCallExpressionName = __webpack_exports__.getCallExpressionName;
+exports.getIgnorePattern = __webpack_exports__.getIgnorePattern;
+exports.getJsxElementName = __webpack_exports__.getJsxElementName;
+exports.getLine = __webpack_exports__.getLine;
+exports.getNodeName = __webpack_exports__.getNodeName;
+exports.getSourceText = __webpack_exports__.getSourceText;
+exports.getStringLiteralValue = __webpack_exports__.getStringLiteralValue;
+exports.getTemplateLiteralValue = __webpack_exports__.getTemplateLiteralValue;
+exports.hasAllowedElementAncestor = __webpack_exports__.hasAllowedElementAncestor;
+exports.hasIgnoreComment = __webpack_exports__.hasIgnoreComment;
+exports.hasLetters = __webpack_exports__.hasLetters;
+exports.isApiEntryFile = __webpack_exports__.isApiEntryFile;
+exports.isApiSourceFile = __webpack_exports__.isApiSourceFile;
+exports.isForbiddenGeneratedEffectPath = __webpack_exports__.isForbiddenGeneratedEffectPath;
+exports.isRecord = __webpack_exports__.isRecord;
+exports.isSharedApiContractFile = __webpack_exports__.isSharedApiContractFile;
+exports.normalizeFilename = __webpack_exports__.normalizeFilename;
+exports.normalizeVisibleText = __webpack_exports__.normalizeVisibleText;
+exports.reportMissingProgramPattern = __webpack_exports__.reportMissingProgramPattern;
+exports.reportProgramPattern = __webpack_exports__.reportProgramPattern;
+exports.reportVisibleText = __webpack_exports__.reportVisibleText;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "asStringArray",
+    "expressionStringValue",
+    "getCallExpressionName",
+    "getIgnorePattern",
+    "getJsxElementName",
+    "getLine",
+    "getNodeName",
+    "getSourceText",
+    "getStringLiteralValue",
+    "getTemplateLiteralValue",
+    "hasAllowedElementAncestor",
+    "hasIgnoreComment",
+    "hasLetters",
+    "isApiEntryFile",
+    "isApiSourceFile",
+    "isForbiddenGeneratedEffectPath",
+    "isRecord",
+    "isSharedApiContractFile",
+    "normalizeFilename",
+    "normalizeVisibleText",
+    "reportMissingProgramPattern",
+    "reportProgramPattern",
+    "reportVisibleText"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/oxlint-plugin/options.cjs

@@ -0,0 +1,172 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    API_ENTRY_PATTERN: ()=>API_ENTRY_PATTERN,
+    API_SOURCE_FILE_PATTERN: ()=>API_SOURCE_FILE_PATTERN,
+    DEFAULT_ALLOWED_ELEMENTS: ()=>DEFAULT_ALLOWED_ELEMENTS,
+    DEFAULT_IGNORE_COMMENT_PATTERN: ()=>DEFAULT_IGNORE_COMMENT_PATTERN,
+    DEFAULT_TRANSLATION_FUNCTIONS: ()=>DEFAULT_TRANSLATION_FUNCTIONS,
+    DEFAULT_VISIBLE_ATTRIBUTES: ()=>DEFAULT_VISIBLE_ATTRIBUTES,
+    FORBIDDEN_GENERATED_EFFECT_PATH_PATTERN: ()=>FORBIDDEN_GENERATED_EFFECT_PATH_PATTERN,
+    LETTER_PATTERN: ()=>LETTER_PATTERN,
+    SHARED_API_CONTRACT_PATTERN: ()=>SHARED_API_CONTRACT_PATTERN,
+    SPLIT_TRANSLATION_KEY_PATTERN: ()=>SPLIT_TRANSLATION_KEY_PATTERN,
+    attributeOptionsSchema: ()=>attributeOptionsSchema,
+    commonOptionsSchema: ()=>commonOptionsSchema,
+    getAttributeRuleOption: ()=>getAttributeRuleOption,
+    getCommonRuleOption: ()=>getCommonRuleOption,
+    getSplitTranslationKeyRuleOption: ()=>getSplitTranslationKeyRuleOption,
+    translationOptionsSchema: ()=>translationOptionsSchema
+});
+const external_ast_cjs_namespaceObject = require("./ast.cjs");
+const commonOptionsSchema = {
+    type: 'object',
+    properties: {
+        allowElements: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        },
+        ignoreCommentPattern: {
+            type: 'string'
+        }
+    },
+    additionalProperties: false
+};
+const attributeOptionsSchema = {
+    type: 'object',
+    properties: {
+        ...commonOptionsSchema.properties,
+        visibleAttributes: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        }
+    },
+    additionalProperties: false
+};
+const translationOptionsSchema = {
+    type: 'object',
+    properties: {
+        translationFunctions: {
+            type: 'array',
+            items: {
+                type: 'string'
+            }
+        }
+    },
+    additionalProperties: false
+};
+const DEFAULT_VISIBLE_ATTRIBUTES = [
+    'aria-label',
+    "aria-description",
+    "aria-roledescription",
+    'aria-valuetext',
+    'alt',
+    'placeholder',
+    'title'
+];
+const DEFAULT_ALLOWED_ELEMENTS = [
+    'code',
+    'kbd',
+    'samp'
+];
+const DEFAULT_TRANSLATION_FUNCTIONS = [
+    't'
+];
+const DEFAULT_IGNORE_COMMENT_PATTERN = 'i18n-ignore';
+const LETTER_PATTERN = /\p{L}/u;
+const SPLIT_TRANSLATION_KEY_PATTERN = /\.(?:prefix|suffix|before|after)$/u;
+const API_SOURCE_FILE_PATTERN = /(?:^|\/)(?:api\/|shared\/api\.[cm]?[jt]sx?$)/u;
+const FORBIDDEN_GENERATED_EFFECT_PATH_PATTERN = /(?:^|\/)(?:(?:apps|verticals)\/[^/]+\/(?:api\/(?:effect|lambda)|shared\/effect|src\/effect))(?:\/|$)/u;
+const API_ENTRY_PATTERN = /(?:^|\/)(?:apps|verticals)\/[^/]+\/api\/index\.[cm]?[jt]sx?$/u;
+const SHARED_API_CONTRACT_PATTERN = /(?:^|\/)(?:apps|verticals)\/[^/]+\/shared\/api\.[cm]?[jt]sx?$/u;
+const getCommonRuleOption = (context, defaults)=>{
+    const options = context.options?.[0];
+    if (!(0, external_ast_cjs_namespaceObject.isRecord)(options)) return defaults;
+    return {
+        allowElements: (0, external_ast_cjs_namespaceObject.asStringArray)(options.allowElements, defaults.allowElements),
+        ignoreCommentPattern: 'string' == typeof options.ignoreCommentPattern ? options.ignoreCommentPattern : defaults.ignoreCommentPattern
+    };
+};
+const getAttributeRuleOption = (context, defaults)=>{
+    const options = context.options?.[0];
+    const commonOptions = getCommonRuleOption(context, defaults);
+    return {
+        ...commonOptions,
+        visibleAttributes: (0, external_ast_cjs_namespaceObject.isRecord)(options) ? (0, external_ast_cjs_namespaceObject.asStringArray)(options.visibleAttributes, defaults.visibleAttributes) : defaults.visibleAttributes
+    };
+};
+const getSplitTranslationKeyRuleOption = (context, defaults)=>{
+    const options = context.options?.[0];
+    if (!(0, external_ast_cjs_namespaceObject.isRecord)(options)) return defaults;
+    return {
+        translationFunctions: (0, external_ast_cjs_namespaceObject.asStringArray)(options.translationFunctions, defaults.translationFunctions)
+    };
+};
+exports.API_ENTRY_PATTERN = __webpack_exports__.API_ENTRY_PATTERN;
+exports.API_SOURCE_FILE_PATTERN = __webpack_exports__.API_SOURCE_FILE_PATTERN;
+exports.DEFAULT_ALLOWED_ELEMENTS = __webpack_exports__.DEFAULT_ALLOWED_ELEMENTS;
+exports.DEFAULT_IGNORE_COMMENT_PATTERN = __webpack_exports__.DEFAULT_IGNORE_COMMENT_PATTERN;
+exports.DEFAULT_TRANSLATION_FUNCTIONS = __webpack_exports__.DEFAULT_TRANSLATION_FUNCTIONS;
+exports.DEFAULT_VISIBLE_ATTRIBUTES = __webpack_exports__.DEFAULT_VISIBLE_ATTRIBUTES;
+exports.FORBIDDEN_GENERATED_EFFECT_PATH_PATTERN = __webpack_exports__.FORBIDDEN_GENERATED_EFFECT_PATH_PATTERN;
+exports.LETTER_PATTERN = __webpack_exports__.LETTER_PATTERN;
+exports.SHARED_API_CONTRACT_PATTERN = __webpack_exports__.SHARED_API_CONTRACT_PATTERN;
+exports.SPLIT_TRANSLATION_KEY_PATTERN = __webpack_exports__.SPLIT_TRANSLATION_KEY_PATTERN;
+exports.attributeOptionsSchema = __webpack_exports__.attributeOptionsSchema;
+exports.commonOptionsSchema = __webpack_exports__.commonOptionsSchema;
+exports.getAttributeRuleOption = __webpack_exports__.getAttributeRuleOption;
+exports.getCommonRuleOption = __webpack_exports__.getCommonRuleOption;
+exports.getSplitTranslationKeyRuleOption = __webpack_exports__.getSplitTranslationKeyRuleOption;
+exports.translationOptionsSchema = __webpack_exports__.translationOptionsSchema;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "API_ENTRY_PATTERN",
+    "API_SOURCE_FILE_PATTERN",
+    "DEFAULT_ALLOWED_ELEMENTS",
+    "DEFAULT_IGNORE_COMMENT_PATTERN",
+    "DEFAULT_TRANSLATION_FUNCTIONS",
+    "DEFAULT_VISIBLE_ATTRIBUTES",
+    "FORBIDDEN_GENERATED_EFFECT_PATH_PATTERN",
+    "LETTER_PATTERN",
+    "SHARED_API_CONTRACT_PATTERN",
+    "SPLIT_TRANSLATION_KEY_PATTERN",
+    "attributeOptionsSchema",
+    "commonOptionsSchema",
+    "getAttributeRuleOption",
+    "getCommonRuleOption",
+    "getSplitTranslationKeyRuleOption",
+    "translationOptionsSchema"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/oxlint-plugin/rules/no-hardcoded-jsx-text.cjs

@@ -0,0 +1,74 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createNoHardcodedJsxTextRule: ()=>createNoHardcodedJsxTextRule
+});
+const external_ast_cjs_namespaceObject = require("../ast.cjs");
+const external_options_cjs_namespaceObject = require("../options.cjs");
+const createNoHardcodedJsxTextRule = ()=>({
+        meta: {
+            type: 'problem',
+            docs: {
+                description: 'Disallow literal user-visible text in JSX children in UltraModern generated apps.'
+            },
+            schema: [
+                external_options_cjs_namespaceObject.commonOptionsSchema
+            ]
+        },
+        create (context) {
+            const options = (0, external_options_cjs_namespaceObject.getCommonRuleOption)(context, {
+                allowElements: external_options_cjs_namespaceObject.DEFAULT_ALLOWED_ELEMENTS,
+                ignoreCommentPattern: external_options_cjs_namespaceObject.DEFAULT_IGNORE_COMMENT_PATTERN
+            });
+            const allowedElements = new Set(options.allowElements);
+            const ignorePattern = (0, external_ast_cjs_namespaceObject.getIgnorePattern)(options);
+            const shouldSkipNode = (node)=>(0, external_ast_cjs_namespaceObject.hasAllowedElementAncestor)(node, allowedElements) || (0, external_ast_cjs_namespaceObject.hasIgnoreComment)(node, context, ignorePattern);
+            return {
+                JSXText (node) {
+                    const text = (0, external_ast_cjs_namespaceObject.normalizeVisibleText)(String(node.value ?? ''));
+                    if (!text || !(0, external_ast_cjs_namespaceObject.hasLetters)(text) || shouldSkipNode(node)) return;
+                    (0, external_ast_cjs_namespaceObject.reportVisibleText)(context, node, text);
+                },
+                JSXExpressionContainer (node) {
+                    if (node.parent?.type !== 'JSXElement' && node.parent?.type !== 'JSXFragment') return;
+                    const text = (0, external_ast_cjs_namespaceObject.normalizeVisibleText)((0, external_ast_cjs_namespaceObject.expressionStringValue)(node.expression) ?? '');
+                    if (!text || !(0, external_ast_cjs_namespaceObject.hasLetters)(text) || shouldSkipNode(node)) return;
+                    (0, external_ast_cjs_namespaceObject.reportVisibleText)(context, node, text);
+                }
+            };
+        }
+    });
+exports.createNoHardcodedJsxTextRule = __webpack_exports__.createNoHardcodedJsxTextRule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNoHardcodedJsxTextRule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/oxlint-plugin/rules/no-legacy-mf-boundary-attributes.cjs

@@ -0,0 +1,61 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createNoLegacyMfBoundaryAttributesRule: ()=>createNoLegacyMfBoundaryAttributesRule
+});
+const external_ast_cjs_namespaceObject = require("../ast.cjs");
+const createNoLegacyMfBoundaryAttributesRule = ()=>({
+        meta: {
+            type: 'problem',
+            docs: {
+                description: 'Disallow legacy Module Federation boundary attributes in generated UltraModern workspaces.'
+            },
+            schema: []
+        },
+        create (context) {
+            return {
+                JSXAttribute (node) {
+                    const attributeName = (0, external_ast_cjs_namespaceObject.getNodeName)(node.name);
+                    if ('data-mf-boundary' !== attributeName && 'data-mf-remote' !== attributeName && 'data-mf-expose' !== attributeName) return;
+                    context.report({
+                        node,
+                        message: 'Use data-modern-boundary-id and data-modern-mf-expose instead of legacy data-mf-* boundary attributes.'
+                    });
+                }
+            };
+        }
+    });
+exports.createNoLegacyMfBoundaryAttributesRule = __webpack_exports__.createNoLegacyMfBoundaryAttributesRule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNoLegacyMfBoundaryAttributesRule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/oxlint-plugin/rules/no-literal-visible-jsx-attributes.cjs

@@ -0,0 +1,74 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createNoLiteralVisibleJsxAttributesRule: ()=>createNoLiteralVisibleJsxAttributesRule
+});
+const external_ast_cjs_namespaceObject = require("../ast.cjs");
+const external_options_cjs_namespaceObject = require("../options.cjs");
+const createNoLiteralVisibleJsxAttributesRule = ()=>({
+        meta: {
+            type: 'problem',
+            docs: {
+                description: 'Disallow literal user-visible JSX attribute text in UltraModern generated apps.'
+            },
+            schema: [
+                external_options_cjs_namespaceObject.attributeOptionsSchema
+            ]
+        },
+        create (context) {
+            const options = (0, external_options_cjs_namespaceObject.getAttributeRuleOption)(context, {
+                allowElements: external_options_cjs_namespaceObject.DEFAULT_ALLOWED_ELEMENTS,
+                ignoreCommentPattern: external_options_cjs_namespaceObject.DEFAULT_IGNORE_COMMENT_PATTERN,
+                visibleAttributes: external_options_cjs_namespaceObject.DEFAULT_VISIBLE_ATTRIBUTES
+            });
+            const visibleAttributes = new Set(options.visibleAttributes);
+            const allowedElements = new Set(options.allowElements);
+            const ignorePattern = (0, external_ast_cjs_namespaceObject.getIgnorePattern)(options);
+            return {
+                JSXAttribute (node) {
+                    const attributeName = (0, external_ast_cjs_namespaceObject.getNodeName)(node.name);
+                    if (!attributeName || !visibleAttributes.has(attributeName)) return;
+                    const text = (0, external_ast_cjs_namespaceObject.normalizeVisibleText)((0, external_ast_cjs_namespaceObject.expressionStringValue)(node.value) ?? '');
+                    if (!text || !(0, external_ast_cjs_namespaceObject.hasLetters)(text) || (0, external_ast_cjs_namespaceObject.hasAllowedElementAncestor)(node, allowedElements) || (0, external_ast_cjs_namespaceObject.hasIgnoreComment)(node, context, ignorePattern)) return;
+                    context.report({
+                        node,
+                        message: `Move literal ${attributeName} copy to locale resources: ${JSON.stringify(text)}`
+                    });
+                }
+            };
+        }
+    });
+exports.createNoLiteralVisibleJsxAttributesRule = __webpack_exports__.createNoLiteralVisibleJsxAttributesRule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNoLiteralVisibleJsxAttributesRule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/oxlint-plugin/rules/no-manual-locale-copy-branching.cjs

@@ -0,0 +1,80 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createNoManualLocaleCopyBranchingRule: ()=>createNoManualLocaleCopyBranchingRule
+});
+const external_ast_cjs_namespaceObject = require("../ast.cjs");
+const looksLikeLocaleTest = (context, node)=>{
+    const text = (0, external_ast_cjs_namespaceObject.getSourceText)(context, node);
+    return /\b(?:language|locale|lng|currentLanguage)\b/u.test(text) && /(?:={2,3}|!==?|\.\s*startsWith\s*\()/u.test(text) && /['"][a-z]{2}(?:-[A-Za-z0-9]+)?['"]/u.test(text);
+};
+const isAllowedBranchLiteral = (text)=>new Set([
+        'page',
+        'undefined',
+        'null',
+        'true',
+        'false'
+    ]).has(text);
+const createNoManualLocaleCopyBranchingRule = ()=>({
+        meta: {
+            type: 'problem',
+            docs: {
+                description: 'Disallow manual locale conditionals that choose user-visible copy.'
+            },
+            schema: []
+        },
+        create (context) {
+            const reportBranch = (node, text)=>{
+                context.report({
+                    node,
+                    message: `Move locale-specific copy branch to i18n resources: ${JSON.stringify(normalizeVisibleText(text))}`
+                });
+            };
+            return {
+                ConditionalExpression (node) {
+                    if (!node.test || !looksLikeLocaleTest(context, node.test)) return;
+                    for (const branch of [
+                        node.consequent,
+                        node.alternate
+                    ]){
+                        const text = expressionStringValue(branch);
+                        if (text && hasLetters(text) && !isAllowedBranchLiteral(text.trim())) reportBranch(branch, text);
+                    }
+                }
+            };
+        }
+    });
+exports.createNoManualLocaleCopyBranchingRule = __webpack_exports__.createNoManualLocaleCopyBranchingRule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNoManualLocaleCopyBranchingRule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});