@wix/origami-lint 1.34.4 → 1.34.6

package/dist/shared/utils.js

@@ -1,43 +1,13 @@
+import { GLOBAL_SECTIONS, RESERVED_ATTRIBUTES, RUNTIME_PACKAGE, SHARED_COMP_ID, STRUCTURE, SYSTEM_PACKAGE, TRANSFORM_BUILDERS } from "./constants.js";
 import { GLOBAL_COMPONENTS, GLOBAL_MENUS } from "./site-files-tree-mapping.js";
-/** Any section: rules that don't care which one. */
-export const SECTIONS = ['section', 'header', 'footer'];
-/** A page's reference to a global component (`<HeaderSection_x sharedCompId="…" />`). */
-export const GLOBAL_SECTIONS = ['globalHeader', 'globalFooter', 'globalSection'];
-/** A tag that wraps one component and isn't one itself: `<Remove when={…}>`, `<Interaction interactKey="…">`. */
-export const WRAPPERS = ['remove', 'interaction'];
-/** The name a structure file exports its tree under: `export const Structure = () => (…)`. */
-export const STRUCTURE = 'Structure';
-/** The props a global component's Structure may take: its instance identity, `({ id, className })` (#300). */
-export const INSTANCE_PROPS = ['id', 'className'];
-const SYSTEM = '@wix/origami-system-components';
-/** The runtime package: the builders (`ctx`, `fn`…) and the `<Remove>` wrapper. */
-export const RUNTIME_PACKAGE = '@wix/origami-runtime';
-/** The runtime's builders: the converter's BINDINGS_BUILDER_ORDER without `Remove`, which is a tag (reservedAttributes.ts). */
-export const BUILDERS = [
-    'all', 'ctx', 'fn', 'is', 'raw', 'state',
-    'textEnum', 'phone', 'email', 'webUrl', 'hostname', 'regex', 'guid', 'direction', 'localDate', 'localTime', 'localDateTime', 'dateTime',
-];
-/** The six builders no other package exports under these names; `email`, `regex`… may well come from a library for fn(). */
-export const RUNTIME_ONLY_BUILDERS = ['all', 'ctx', 'fn', 'is', 'raw', 'state'];
-/** The attributes the converter reads on any component as something other than its data (reservedAttributes.ts RESERVED_ATTRIBUTES, converter 0.81: `type` is data since). */
-export const RESERVED_ATTRIBUTES = [
-    'id', '_id', 'data', 'props', 'skin', 'styleId', 'className', 'documentType', 'style', 'slot', 'bindings', 'elementProps',
-];
-/** The attribute of a page's reference to a global component (SHARED_COMP_ID_ATTR); on any other tag it's data. */
-export const SHARED_COMP_ID = 'sharedCompId';
-/** The keys of an elementProps entry the converter reads as something other than the part's data (RESERVED_INNER_ELEMENT_ENTRY_KEYS, converter 0.80). */
-export const RESERVED_ENTRY_KEYS = ['data', 'slots', 'elementProps', 'bindings', 'className'];
-/** A data key is a JavaScript name (dataKeys.ts). */
-export const DATA_KEY = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-/** By import source; the wrappers also by the imported name, since their packages export other things (`Show`, `Interact`). */
 const TYPE_BY_IMPORT_SOURCE = [
-    [new RegExp(`^${SYSTEM}/(?:layout/)?Page$`), 'page'],
-    [new RegExp(`^${SYSTEM}/layout/Header$`), 'headerLandmark'],
-    [new RegExp(`^${SYSTEM}/layout/Footer$`), 'footerLandmark'],
-    [new RegExp(`^${SYSTEM}/(?:layout/)?Section$`), 'section'],
-    [new RegExp(`^${SYSTEM}/(?:layout/)?HeaderSection$`), 'header'],
-    [new RegExp(`^${SYSTEM}/(?:layout/)?FooterSection$`), 'footer'],
-    [new RegExp(`^${SYSTEM}/InternalContainer$`), 'innerElement'],
+    [new RegExp(`^${SYSTEM_PACKAGE}/(?:layout/)?Page$`), 'page'],
+    [new RegExp(`^${SYSTEM_PACKAGE}/layout/Header$`), 'headerLandmark'],
+    [new RegExp(`^${SYSTEM_PACKAGE}/layout/Footer$`), 'footerLandmark'],
+    [new RegExp(`^${SYSTEM_PACKAGE}/(?:layout/)?Section$`), 'section'],
+    [new RegExp(`^${SYSTEM_PACKAGE}/(?:layout/)?HeaderSection$`), 'header'],
+    [new RegExp(`^${SYSTEM_PACKAGE}/(?:layout/)?FooterSection$`), 'footer'],
+    [new RegExp(`^${SYSTEM_PACKAGE}/InternalContainer$`), 'innerElement'],
     // A global component's folder is `<Type>_<id>`: HeaderSection_mb7ogqqn.
     [new RegExp(`/${GLOBAL_COMPONENTS}/(?:HeaderSection|Header)_[^/]+$`), 'globalHeader'],
     [new RegExp(`/${GLOBAL_COMPONENTS}/(?:FooterSection|Footer)_[^/]+$`), 'globalFooter'],
@@ -54,6 +24,8 @@ const KIND_BY_IMPORT_SOURCE = [
     [new RegExp(`^(\\.\\.?/)*${GLOBAL_MENUS}(/|$)`), 'menu'],
     [/^document$/, 'core'],
     [/^document\//, 'document'],
+    [/^@origami-wrappers\//, 'wrapper'],
+    [/^@site\/site-code\/[^/]+$/, 'siteCode'],
 ];
 /** <Band> with `import { Section as Band } from '@wix/origami-system-components/Section'` → 'section'. `<Band.Item>` is Band's. A wrapper is the named export: `<Show>` from the runtime is null. */
 export function getType(element, program) {
@@ -64,6 +36,15 @@ export function getType(element, program) {
     const [, type, imported] = entry;
     return imported === undefined || found.imported === imported ? type : null;
 }
+/** The tags the import reads as the DM's own components ('document') or a global component's reference (identity.ts identityOfTag): no data attributes. */
+const NO_DATA_TYPES = ['page', 'section', 'header', 'footer', 'headerLandmark', 'footerLandmark', ...GLOBAL_SECTIONS];
+/** Converter 0.81: are the tag's attributes saved as its component's data? Yes on a builder component (its import gives a componentType):
+ * imported, not from `document` and not from a local file. No on the DM's own tags (`Page`, the sections) and a global component's reference. */
+export function hasDataAttributes(element, program) {
+    const found = getImport(getTagName(element).split('.')[0], program);
+    const type = getType(element, program);
+    return found !== null && found.kind !== 'core' && !found.source.startsWith('.') && !(type && NO_DATA_TYPES.includes(type));
+}
 /** What an import's source is: 'runtime' for @wix/origami-runtime, 'interact' for @wix/interact/…; null for anything else. */
 export const getImportKind = (source) => KIND_BY_IMPORT_SOURCE.find(([pattern]) => pattern.test(source))?.[1] ?? null;
 /** Where a name of the file comes from; null when no import brings it in. */
@@ -109,7 +90,6 @@ export function getSlot(element) {
     return getLiteralString(element.openingElement.attributes.find(isSlotAttribute)?.value);
 }
 /** The attributes that hold an element's layers: drawn behind it, and pinned to it. */
-export const LAYER_ATTRIBUTES = ['backgroundLayer', 'pinnedLayer'];
 /** The elements this one holds in its attributes (`content={<X />}`, or inside the attribute's object or array, `elementProps` too), each with the attribute it is in. Not its children, and not the elements inside those elements. */
 export function getAttributeElements(owner) {
     const elementsIn = (value) => {
@@ -142,6 +122,15 @@ export function getExpression(attribute) {
         return null;
     return bare(value.expression);
 }
+/** The object written out in a value, in parentheses or in an attribute's `{…}`: `x={{ a: 1 }}` → `{ a: 1 }`; null for any other value. */
+export function getObject(node) {
+    if (!node)
+        return null;
+    const value = node.type === 'JSXAttribute' ? getExpression(node) : bare(node);
+    return value?.type === 'ObjectExpression' ? value : null;
+}
+/** Not the component's data: the converter's reserved attributes, and `sharedCompId` (reservedAttributes.ts). */
+export const isReservedAttribute = (name) => RESERVED_ATTRIBUTES.includes(name) || name === SHARED_COMP_ID;
 /** The node inside its parentheses: `((x))` → `x`. */
 export function bare(node) {
     return node.type === 'ParenthesizedExpression' ? bare(node.expression) : node;
@@ -162,6 +151,52 @@ export function isStructure(node) {
     return declarator?.type === 'VariableDeclarator' && declarator.id?.type === 'Identifier' && declarator.id.name === STRUCTURE
         && declarator.parent?.parent?.type === 'ExportNamedDeclaration' && declarator.parent.parent.parent?.type === 'Program';
 }
+/** The node's parent, past parentheses, and its child on the way up: the node itself, or the parentheses around it. */
+function getOuter(node) {
+    let child = node;
+    while (child.parent?.type === 'ParenthesizedExpression')
+        child = child.parent;
+    return [child.parent, child];
+}
+/** The callbacks whose parameters the import reads as bindings: 'template' for a slot's template, `renderItem={(item, index, length) => <X />}`, an attribute's
+ * arrow that returns one element (parseJsx.ts templateCallbackOf); 'transform' for `map(source, (item, index) => ({…}))` and `shape(source, (obj) => ({…}))`
+ * (astValue.ts transformCallbackOf). null for any other node. */
+export function getCallbackKind(syntax) {
+    const node = syntax;
+    if (node.type !== 'ArrowFunctionExpression')
+        return null;
+    let body = node.body;
+    while (body?.type === 'ParenthesizedExpression')
+        body = body.expression;
+    const [outer, child] = getOuter(node);
+    if (body?.type === 'JSXElement' && outer?.type === 'JSXExpressionContainer' && outer.parent?.type === 'JSXAttribute')
+        return 'template';
+    const isTransform = outer?.type === 'CallExpression' && outer.callee?.type === 'Identifier' && TRANSFORM_BUILDERS.includes(outer.callee.name) && outer.arguments?.[1] === child;
+    return isTransform ? 'transform' : null;
+}
+/** A read of a callback's parameter, `item`, `item.name`, `item['link-1']`, which the import reads as a binding (astValue.ts templateReadOf):
+ * 'template' off a renderItem's parameter, 'transform' off a map() or shape() callback's. null for any other value, or inside any other function. */
+export function getParamReadKind(syntax) {
+    const node = syntax;
+    let root = node;
+    while (root.type === 'MemberExpression' && root.object)
+        root = root.object;
+    if (root.type !== 'Identifier')
+        return null;
+    for (let up = node.parent; up && up.type !== 'Program'; up = up.parent) {
+        if (up.type !== 'ArrowFunctionExpression' && up.type !== 'FunctionExpression')
+            continue;
+        const kind = getCallbackKind(up);
+        if (!kind)
+            return null;
+        if (up.params?.some((param) => param.type === 'Identifier' && param.name === root.name))
+            return kind;
+    }
+    return null;
+}
+/** A call, or a read of a renderItem / map() parameter (`item.name`): the import reads it as a binding, not as data (parseJsx.ts takeBoundProp).
+ * Any call: the bindings rule reports one that isn't a builder. */
+export const isBound = (value) => !!value && (value.type === 'CallExpression' || getParamReadKind(value) !== null);
 /** A component in a message: `<Image>` img, or `<Image>` when it has no id. */
 export function ownerOf(element) {
     const id = getId(element);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-lint",
-  "version": "1.34.4",
+  "version": "1.34.6",
   "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": "dae194e28b366afdeb725197b97b0f1659346d4dbe5cea8e1659dab4"
+  "falconPackageHash": "bb0df5db12e07d7822c9dfb05afde996c91aa84c7842621d1e8245f2"
 }