@bleedingdev/modern-js-code-tools 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

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
+});

package/dist/cjs/oxlint-plugin/rules/no-split-translation-keys.cjs

@@ -0,0 +1,70 @@
+"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__, {
+    createNoSplitTranslationKeysRule: ()=>createNoSplitTranslationKeysRule
+});
+const external_ast_cjs_namespaceObject = require("../ast.cjs");
+const external_options_cjs_namespaceObject = require("../options.cjs");
+const createNoSplitTranslationKeysRule = ()=>({
+        meta: {
+            type: 'problem',
+            docs: {
+                description: 'Disallow split phrase translation key suffixes such as .prefix and .suffix.'
+            },
+            schema: [
+                external_options_cjs_namespaceObject.translationOptionsSchema
+            ]
+        },
+        create (context) {
+            const options = (0, external_options_cjs_namespaceObject.getSplitTranslationKeyRuleOption)(context, {
+                translationFunctions: external_options_cjs_namespaceObject.DEFAULT_TRANSLATION_FUNCTIONS
+            });
+            const translationFunctions = new Set(options.translationFunctions);
+            return {
+                CallExpression (node) {
+                    const calleeName = (0, external_ast_cjs_namespaceObject.getCallExpressionName)(node.callee);
+                    if (!calleeName || !translationFunctions.has(calleeName)) return;
+                    const key = (0, external_ast_cjs_namespaceObject.expressionStringValue)(node.arguments?.[0]);
+                    if (!key || !external_options_cjs_namespaceObject.SPLIT_TRANSLATION_KEY_PATTERN.test(key)) return;
+                    context.report({
+                        node,
+                        message: 'Keep translator-owned phrases whole instead of using split translation keys.'
+                    });
+                }
+            };
+        }
+    });
+exports.createNoSplitTranslationKeysRule = __webpack_exports__.createNoSplitTranslationKeysRule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNoSplitTranslationKeysRule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/oxlint-plugin/rules/strict-effect-api-boundaries.cjs

@@ -0,0 +1,84 @@
+"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__, {
+    createStrictEffectApiBoundariesRule: ()=>createStrictEffectApiBoundariesRule
+});
+const external_ast_cjs_namespaceObject = require("../ast.cjs");
+const createStrictEffectApiBoundariesRule = ()=>({
+        meta: {
+            type: 'problem',
+            docs: {
+                description: 'Disallow raw HTTP handlers and non-Effect API runtime drift in UltraModern workspaces.'
+            },
+            schema: []
+        },
+        create (context) {
+            return {
+                Program (node) {
+                    const source = (0, external_ast_cjs_namespaceObject.getSourceText)(context, node);
+                    const filename = (0, external_ast_cjs_namespaceObject.normalizeFilename)(context.filename);
+                    const apiFile = (0, external_ast_cjs_namespaceObject.isApiSourceFile)(filename);
+                    if ((0, external_ast_cjs_namespaceObject.isForbiddenGeneratedEffectPath)(filename)) context.report({
+                        node,
+                        message: 'Generated UltraModern workspaces use direct api/index.ts, shared/api.ts and src/api/* paths; api/effect, api/lambda, shared/effect and src/effect are forbidden.'
+                    });
+                    (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /@modern-js\/plugin-bff\/hono-server/u, 'UltraModern API workspaces must not import Hono server helpers; use @modern-js/plugin-bff/effect-edge and HttpApi.');
+                    (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /\bruntimeFramework\s*(?::|=)\s*['"]hono['"]/u, 'UltraModern API apps must use bff.runtimeFramework: "effect".');
+                    (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /(?:from|import)\s*['"][^'"]*(?:api\/effect|shared\/effect)[^'"]*['"]|shared-effect-api/u, 'Import API code from direct api/index.ts, shared/api.ts or src/api/* paths, not api/effect, shared/effect or shared Effect API packages.');
+                    (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /\bstrictEffectApproach\s*(?::|=)\s*false\b/u, 'UltraModern API apps must keep strictEffectApproach enabled.');
+                    if ((0, external_ast_cjs_namespaceObject.isApiEntryFile)(filename)) {
+                        (0, external_ast_cjs_namespaceObject.reportMissingProgramPattern)(context, node, source, /\bdefineEffectBff\b/u, 'Generated API entries must export defineEffectBff(...).');
+                        (0, external_ast_cjs_namespaceObject.reportMissingProgramPattern)(context, node, source, /\bHttpApiBuilder\b/u, 'Generated API entries must implement handlers through HttpApiBuilder.');
+                        (0, external_ast_cjs_namespaceObject.reportMissingProgramPattern)(context, node, source, /\bLayer\b/u, 'Generated API entries must compose dependencies with Effect Layer.');
+                        (0, external_ast_cjs_namespaceObject.reportMissingProgramPattern)(context, node, source, /from\s+['"]\.\.\/shared\/api\.ts['"]/u, 'Generated API entries must import the contract from ../shared/api.ts.');
+                    }
+                    if ((0, external_ast_cjs_namespaceObject.isSharedApiContractFile)(filename)) {
+                        (0, external_ast_cjs_namespaceObject.reportMissingProgramPattern)(context, node, source, /\bHttpApi\.make\b/u, 'Generated shared API contracts must declare an HttpApi contract.');
+                        (0, external_ast_cjs_namespaceObject.reportMissingProgramPattern)(context, node, source, /\bHttpApiGroup\.make\b/u, 'Generated shared API contracts must declare HttpApi groups.');
+                        (0, external_ast_cjs_namespaceObject.reportMissingProgramPattern)(context, node, source, /\bHttpApiEndpoint\./u, 'Generated shared API contracts must declare endpoints through HttpApiEndpoint.');
+                        (0, external_ast_cjs_namespaceObject.reportMissingProgramPattern)(context, node, source, /\bSchema\./u, 'Generated shared API contracts must model request, response and error shapes with Schema.');
+                    }
+                    if (!apiFile) return;
+                    (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /\bnew\s+Response\s*\(|\bResponse\.json\s*\(/u, 'API modules must not hand-build Response objects; model endpoints through Effect HttpApi and schemas.');
+                    (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /\b(?:request|req)\.(?:json|text|formData|arrayBuffer)\s*\(/u, 'API modules must not manually parse request bodies; use HttpApiEndpoint payload/query/params schemas.');
+                    (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /\bexport\s+const\s+handler\b|\bexport\s+default\s+async\b/u, 'API modules must not export raw request handlers; export defineEffectBff(...) from api/index.ts.');
+                    (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /\bcreateHandler\s*[:=]\s*(?!defineEffectBff\b)/u, 'API modules must not define unbranded handler factories; use defineEffectBff(...).');
+                    (0, external_ast_cjs_namespaceObject.reportProgramPattern)(context, node, source, /\bSchema\.(?:UnknownFromJsonString|Unknown|Any)\b/u, 'API modules must use concrete request, response and error schemas; Schema.UnknownFromJsonString, Schema.Unknown and Schema.Any are forbidden in UltraModern API code.');
+                }
+            };
+        }
+    });
+exports.createStrictEffectApiBoundariesRule = __webpack_exports__.createStrictEffectApiBoundariesRule;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createStrictEffectApiBoundariesRule"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});