@wix/origami-lint 1.34.2 → 1.34.4

package/dist/lint.js

@@ -1,13 +1,17 @@
 #!/usr/bin/env node
-// Origami lint: lints the pages whose files changed since the last passing run. See lint/README.md.
+// Origami lint: runs the project rules on the site's own files, then lints the pages whose files changed since the last
+// passing run. See lint/README.md.
 import { getChangedFiles, markPassing } from "./history/index.js";
 import { runRules } from "./rules-adapter/index.js";
 import { findPagesToLint } from "./page-model/index.js";
+import { runProjectRules } from "./project-rules-runner/index.js";
 import { checkStartedAtSiteRoot } from "./shared/paths.js";
 checkStartedAtSiteRoot();
 const changedFiles = getChangedFiles();
+const projectPassed = runProjectRules(changedFiles.all);
 const pagesToLint = findPagesToLint(changedFiles);
-const passed = runRules(pagesToLint);
+const pagesPassed = runRules(pagesToLint);
+const passed = projectPassed && pagesPassed;
 if (passed)
     markPassing(changedFiles);
 process.exit(passed ? 0 : 1);

package/dist/project-model/index.js

@@ -0,0 +1,2 @@
+// The project model, beside the page model (part 2): what a project rule sees of the site.
+export { createProjectModel } from "./project-model.js";

package/dist/project-model/project-model.js

@@ -0,0 +1,15 @@
+/** A path from the site root that stays inside the site: no leading /, no .. segment. */
+function isSitePath(file) {
+    return !file.startsWith('/') && !file.split('/').includes('..');
+}
+/** The rule's view of the site: its files, and readFile. ruleName names the rule in readFile's error. */
+export function createProjectModel(ruleName, files, readFile) {
+    return {
+        files,
+        readFile(file) {
+            if (!isSitePath(file))
+                throw new Error(`project rule ${ruleName} read ${file}: write a path from the site root, without ..`);
+            return readFile(file);
+        },
+    };
+}

package/dist/project-rules-runner/index.js

@@ -0,0 +1,3 @@
+// The project rules runner, beside the rules adapter (part 5): runs the rules that check the site's own files and
+// folders (lint/rules/project/), not one page.
+export { runProjectRules } from "./run-project-rules.js";

package/dist/project-rules-runner/run-project-rules.js

@@ -0,0 +1,44 @@
+// Runs every project rule, on every run, on the whole site; prints each problem in the line shape the page rules'
+// problems print in.
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { projectRuleRegistry } from "../rules/project/index.js";
+import { log } from "../shared/log.js";
+import { ROOT } from "../shared/paths.js";
+import { createProjectModel } from "../project-model/index.js";
+/** true when no error rule reported a problem, on the site of these files. Logs how many rules run, and whether they passed. */
+export function runProjectRules(files, { rules = projectRuleRegistry, readFile = readFromSite, print = console.log } = {}) {
+    log(`${rules.length} project rules to run`);
+    let passed = true;
+    for (const rule of rules) {
+        let problems;
+        try {
+            problems = rule.check(createProjectModel(rule.name, files, readFile));
+        }
+        catch (error) {
+            // A rule that couldn't finish (a file it can't parse, a path out of the site) fails the run, whatever its severity.
+            print(formatProblem({ name: rule.name }, { file: '.', message: `the rule couldn't finish, so this run can't pass: ${error instanceof Error ? error.message : String(error)}` }));
+            passed = false;
+            continue;
+        }
+        for (const problem of problems) {
+            print(formatProblem(rule, problem));
+            if ((rule.severity ?? 'error') === 'error')
+                passed = false;
+        }
+    }
+    log(passed ? 'project rules passed' : 'project rules failed');
+    return passed;
+}
+/** `file:line:1: error origami(name): message`, the shape oxlint prints the page rules' problems in. */
+export function formatProblem({ name, severity = 'error' }, { file, line = 1, message }) {
+    return `${file}:${line}:1: ${severity === 'error' ? 'error' : 'warning'} origami(${name}): ${message}`;
+}
+function readFromSite(file) {
+    try {
+        return readFileSync(path.join(ROOT, file), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/rules/page-structure.js

@@ -6,6 +6,8 @@
 // recognized by import source (rulesApi.getType), so renaming an import doesn't matter.
 // Checked in every file, pages and global components alike:
 // - Structure returns one element, with a string id (tracker CONV-runValidation.ts:9);
+// - every section, wherever it sits (a page's, a global component's top one, one nested lower down), holds exactly one
+//   <InternalContainer> and nothing else: the site's own build refuses anything else (rule S2-SECTION-001, tracker OUR-001);
 // - a <Page> is only ever the top of its own page: one held by another element is refused at save (rule card P1-R16);
 // - the header and footer sit outside every <InternalContainer>: inside one, that container can no longer be deleted in the
 //   editor (rule card P1-R03). Both the HeaderSection / FooterSection tags and a page's reference to the global ones;
@@ -38,6 +40,8 @@ export default defineRule({
             if (isLandmark(input.node, input.rulesApi))
                 hasSectionInLandmark(input);
             hasOnlyElements(input);
+            if (isSection(input.node, input.rulesApi))
+                hasOneInternalContainer(input.node, input);
             hasLayerArrays(input);
             isNotNestedPage(input);
             isOutsideInternalContainers(input);
@@ -50,8 +54,7 @@ export default defineRule({
                 return;
             if (!startsWithPage(input))
                 return;
-            for (const section of getSections(input))
-                hasOneInternalContainer(section, input);
+            checkPageChildren(input);
         },
     },
 });
@@ -94,29 +97,25 @@ function startsWithPage({ node, rulesApi, report }) {
     report({ loc: getLoc(node, rulesApi), message: `A page must start with <Page>, found ${describe(node, rulesApi)}.` });
     return false;
 }
-/** <Page>'s sections. Any other component (the page's <Background>, a pinned element) is accepted, as the import accepts it; reports text and {…} (CONV-parseJsx.ts:1668). */
-function getSections({ node: page, rulesApi, report }) {
-    const sections = [];
+/** Reports text and {…} directly in <Page> (CONV-parseJsx.ts:1668). Any component is accepted there: a section, the page's <Background>, a pinned element, as the import accepts it. */
+function checkPageChildren({ node: page, rulesApi, report }) {
     for (const child of getStructuralChildren(page, rulesApi)) {
-        if (child.type === 'JSXElement') {
-            const type = rulesApi.getType(child);
-            if (type && SECTIONS.includes(type))
-                sections.push(child);
+        if (child.type === 'JSXElement')
             continue;
-        }
         report({ loc: getLoc(page, rulesApi), message: `<Page> has ${describe(child, rulesApi)} as a child. Only elements go directly inside <Page>: a section, or a component pinned to the page (tracker CONV-parseJsx.ts:1668).` });
     }
-    return sections;
 }
-/** Reports a section that doesn't hold exactly one <InternalContainer>, and nothing else. A wrapper in it that holds the wrong number of elements is reported by its own step first. */
+/** Reports a section, anywhere in the file, that doesn't hold exactly one <InternalContainer>, and nothing else (S2-SECTION-001, OUR-001). A wrapper in it
+ * that holds the wrong number of elements is reported by its own step first; text and {…} count only where hasOnlyElements leaves them to this step. */
 function hasOneInternalContainer(section, { rulesApi, report }) {
     if (rulesApi.getChildren(section).some((child) => child.type === 'JSXElement' && isWrapper(child, rulesApi) && !holdsOne(child)))
         return;
-    const inside = getStructuralChildren(section, rulesApi);
+    const reportsText = isRootTreeHolder(section, rulesApi);
+    const inside = getStructuralChildren(section, rulesApi).filter((child) => reportsText || child.type === 'JSXElement');
     if (inside.length === 1 && inside[0].type === 'JSXElement' && rulesApi.getType(inside[0]) === 'innerElement')
         return;
     const name = rulesApi.getId(section) ?? `<${rulesApi.getTagName(section)}>`;
-    report({ loc: getLoc(section, rulesApi), message: `Section ${name} must contain exactly one <InternalContainer>, found: ${inside.map((child) => describe(child, rulesApi)).join(', ') || 'nothing'}.` });
+    report({ loc: getLoc(section, rulesApi), message: `Section ${name} must contain exactly one <InternalContainer>, found: ${inside.map((child) => describe(child, rulesApi)).join(', ') || 'nothing'}. Put the section's content inside its one <InternalContainer> (rule S2-SECTION-001).` });
 }
 /** Reports a <Page> held by another element (P1-R16), unless the root steps above report that placement already (a section's children). */
 function isNotNestedPage({ node, rulesApi, report }) {
@@ -250,6 +249,11 @@ function describe(child, rulesApi) {
         return `<${rulesApi.getTagName(child)}>`;
     return child.type === 'JSXText' ? 'text' : 'a {…} expression';
 }
+/** Section, HeaderSection, FooterSection (by import source); not a page's reference to a global one. */
+function isSection(node, rulesApi) {
+    const type = rulesApi.getType(node);
+    return type !== null && SECTIONS.includes(type);
+}
 function isLandmark(node, rulesApi) {
     const type = rulesApi.getType(node);
     return type === 'headerLandmark' || type === 'footerLandmark';
@@ -259,10 +263,8 @@ function hasSectionInLandmark(input) {
     const { node, rulesApi, report } = input;
     const expected = rulesApi.getType(node) === 'headerLandmark' ? 'header' : 'footer';
     const children = getStructuralChildren(node, rulesApi);
-    if (children.length === 1 && children[0].type === 'JSXElement' && rulesApi.getType(children[0]) === expected) {
-        hasOneInternalContainer(children[0], input);
+    if (children.length === 1 && children[0].type === 'JSXElement' && rulesApi.getType(children[0]) === expected)
         return;
-    }
     report({ loc: getLoc(node, rulesApi), message: `<${rulesApi.getTagName(node)}> must contain exactly one ${expected === 'header' ? 'HeaderSection' : 'FooterSection'}.` });
 }
 function receivesInstanceId(node) {

package/dist/rules/project/define-project-rule.js

@@ -0,0 +1,4 @@
+/** Nothing changes a rule once it's defined. */
+export function defineProjectRule(rule) {
+    return Object.freeze({ ...rule, scope: 'project' });
+}

package/dist/rules/project/index.js

@@ -0,0 +1,2 @@
+export { defineProjectRule } from "./define-project-rule.js";
+export const projectRuleRegistry = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-lint",
-  "version": "1.34.2",
+  "version": "1.34.4",
   "description": "Offline lint for an exported Origami site: lints the pages that changed since the last passing run",
   "type": "module",
   "bin": {
@@ -51,5 +51,5 @@
       ]
     }
   },
-  "falconPackageHash": "b4530d28f7fd3cf6e883a2f9ab79852ec1f94c67e1fa6b2ae68ace9a"
+  "falconPackageHash": "dae194e28b366afdeb725197b97b0f1659346d4dbe5cea8e1659dab4"
 }