@wix/origami-lint 1.34.22 → 1.34.24

package/dist/rules/index.js

@@ -10,9 +10,10 @@ import globalStyles from "./site-app/global-styles.js";
 import noAbsoluteSection from "./site-app/no-absolute-section.js";
 import pageStructure from "./site-app/page-structure.js";
 import slotAttributes from "./site-app/slot-attributes.js";
+import slotPlacement from "./site-app/slot-placement.js";
 import themeFontIds from "./site-app/theme-font-ids.js";
 import themeRoot from "./site-app/theme-root.js";
 import noFreeCode from "./site-app/no-free-code.js";
 // Execution registries combine already-checked rules; only this boundary erases their individual key unions.
-export const ruleRegistry = [allowedImports, noFreeCode, pageStructure, noAbsoluteSection, themeFontIds, slotAttributes, themeRoot, breakpoints, cssFileNesting, globalStyles, applyAndPresets, bindings, dataValues, cssLayoutProperties, cssSelectors];
+export const ruleRegistry = [allowedImports, noFreeCode, pageStructure, noAbsoluteSection, themeFontIds, slotAttributes, themeRoot, breakpoints, cssFileNesting, globalStyles, applyAndPresets, bindings, dataValues, cssLayoutProperties, cssSelectors, slotPlacement];
 export { defineRule } from "./site-app/define-rule.js";

package/dist/rules/site-app/data-values.js

@@ -2,7 +2,7 @@
 // 1227, 1231, 1235, 1255, 1268, 1289, 1697; projectData.ts 214, 225, 281, 435, 443; enrichImage.ts 94, 105.
 // Converter 0.81 (checked at 0.84, 2c0e21c): the tag's import, not a `type` attr, decides if a component takes data attributes; `type` is data.
 import { isDeepStrictEqual } from 'node:util';
-import { DATA_KEY, EVENT_ATTRIBUTE, RESERVED_ATTRIBUTES, RESERVED_ENTRY_KEYS, bare, getAttribute, getExpression, getKey, getName, getObject, getProperties, getCallbackKind, getProperty, isBound, isOneEditAway, isReservedAttribute, isStructure, ownerOf, } from "../../rules-api/index.js";
+import { DATA_KEY, EVENT_ATTRIBUTE, RESERVED_ATTRIBUTES, RESERVED_ENTRY_KEYS, bare, getAttribute, getExpression, getKey, getName, getObject, getProperties, getCallbackKind, getProperty, isBound, isOneEditAway, isReadByImport, isReservedAttribute, ownerOf, } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
 const CHECKS = ['attribute_without_braces', 'non_literal_data', 'duplicate_element_prop', 'invalid_element_props_object', 'invalid_element_props_entry', 'invalid_data_object', 'invalid_element_props_key', 'unsupported_element_props_key', 'mixed_data_wrapper', 'duplicate_data_key', 'bare_document_href', 'missing_document_id', 'inconsistent_image_url', 'misplaced_image_url_call'];
 /** The names the import never reads as data (dataKeys.ts). The React name is joined as the converter does: Wix Standards fails the build on it in any file. */
@@ -43,7 +43,7 @@ export default defineRule({
 // ── the callback's steps ──
 /** A component written out under Structure: its data values, then what the import builds from the ones it read. */
 function checkJSXElementDataValues(input) {
-    if (!input.rulesApi.getComponent(input.node) || !isWrittenOut(input.node))
+    if (!input.rulesApi.getComponent(input.node) || !isReadByImport(input.node))
         return;
     const elementProps = getAttribute(input.node, 'elementProps');
     const keysOnce = !elementProps || checkEntryKeysOnce(input, elementProps);
@@ -491,14 +491,3 @@ function dataValues(input) {
     }
     return values;
 }
-/** In Structure's own JSX, or in a renderItem template, which the import reads in the row's scope (parseJsx.ts claimSlotChild). */
-function isWrittenOut(element) {
-    for (let up = element.parent; up.type !== 'JSXElement' && up.type !== 'Program'; up = up.parent) {
-        if (up.type === 'ArrowFunctionExpression')
-            return isStructure(up) || getCallbackKind(up) === 'template';
-        if (NOT_READ_IN.includes(up.type) || (up.type === 'JSXExpressionContainer' && up.parent.type !== 'JSXAttribute'))
-            return false;
-    }
-    return true;
-}
-const NOT_READ_IN = ['FunctionExpression', 'CallExpression', 'ConditionalExpression', 'LogicalExpression'];

package/dist/rules/site-app/slot-attributes.js

@@ -5,7 +5,7 @@
 // - the root element has no `slot=`: it has no owner to be a slot of (CONV-fromBundle.ts:1312);
 // - two children of one owner don't share a slot key (CONV-slots.ts:555).
 // Children are the element children and the layer elements (backgroundLayer, pinnedLayer); <Remove> and <Interaction> are transparent.
-import { LAYER_ATTRIBUTES, WRAPPERS } from "../../rules-api/index.js";
+import { ELEMENT_PROPS, LAYER_ATTRIBUTES, WRAPPERS } from "../../rules-api/index.js";
 import { defineRule } from "./define-rule.js";
 const CHECKS = ['root_has_slot', 'attribute_child_has_slot', 'mixed_slot_forms', 'duplicate_slot'];
 export default defineRule({
@@ -78,13 +78,13 @@ const getSlottedChildren = (owner, rulesApi) => [...rulesApi.getChildElements(ow
     .filter((child) => rulesApi.getSlot(child) !== null);
 /** `elementProps={{ panel: { slots: {…} } }}`, or the same in a nested `elementProps` of an entry. */
 function hasEntrySlots(owner) {
-    const attribute = owner.openingElement.attributes.find((candidate) => candidate.type === 'JSXAttribute' && getAttributeName(candidate) === 'elementProps');
+    const attribute = owner.openingElement.attributes.find((candidate) => candidate.type === 'JSXAttribute' && getAttributeName(candidate) === ELEMENT_PROPS);
     return attribute?.type === 'JSXAttribute' && attribute.value?.type === 'JSXExpressionContainer' && entriesHaveSlots(attribute.value.expression);
 }
 function entriesHaveSlots(entries) {
     if (entries.type !== 'ObjectExpression')
         return false;
-    return entries.properties.some((entry) => entry.type === 'Property' && entry.value.type === 'ObjectExpression' && entry.value.properties.some((property) => property.type === 'Property' && (getKeyName(property) === 'slots' || (getKeyName(property) === 'elementProps' && entriesHaveSlots(property.value)))));
+    return entries.properties.some((entry) => entry.type === 'Property' && entry.value.type === 'ObjectExpression' && entry.value.properties.some((property) => property.type === 'Property' && (getKeyName(property) === 'slots' || (getKeyName(property) === ELEMENT_PROPS && entriesHaveSlots(property.value)))));
 }
 const getKeyName = (property) => property.computed ? null : property.key.type === 'Identifier' ? property.key.name : property.key.type === 'Literal' ? String(property.key.value) : null;
 const getAttributeName = (attribute) => (attribute.name.type === 'JSXIdentifier' ? String(attribute.name.name) : '');

package/dist/rules/site-app/slot-placement.js

@@ -0,0 +1,107 @@
+import { DATA_KEY, ELEMENT_PROPS, isRecord, isReadByImport, LAYER_ATTRIBUTES, RESERVED_ATTRIBUTES, RESERVED_ENTRY_KEYS, SHARED_COMP_ID } from "../../rules-api/index.js";
+import { defineRule } from "./define-rule.js";
+const CHECKS = ['attribute_slot_place', 'element_props_slot_place', 'slot_owner_data_object'];
+/** The names the import keeps for itself, so a slot can't sit under one: the converter's EMITTED_ATTR_NAMES. */
+const RESERVED_KEYS = new Set([...RESERVED_ATTRIBUTES, SHARED_COMP_ID, 'backgroundLayer']);
+/** An inner part's name: a safe CSS identifier, and not an object key the import keeps out. Copied from the DM converter's isSafeCssIdentifier: https://github.com/wix-private/document-management/blob/e1d9b91f44d7ea8d6c1203dbfd26ee58a7f7079f/document-management-jsx-converter/src/css-codec/css/cssSelectors.ts#L47-L50 */
+const PART_NAME = /^-?[_a-zA-Z]+[_a-zA-Z0-9-]*$/;
+const UNSAFE_PART_NAMES = new Set(['__proto__', 'constructor', 'prototype']);
+export default defineRule({
+    name: 'slot-placement',
+    checks: CHECKS,
+    editors: ['studio2'],
+    callbacks: {
+        JSXElement: (input) => {
+            if (!input.rulesApi.getComponent(input.node) || !isReadByImport(input.node))
+                return;
+            const slots = input.rulesApi.getAttributeElements(input.node).filter(({ name }) => !LAYER_ATTRIBUTES.includes(name));
+            checkSlotPlaces(slots, input);
+            checkSlotOwnerData(slots, input);
+        },
+    },
+});
+/** Reports each element at a place the import can't write back (CONV-parseJsx.ts:1532, :1571 and the repeats at CONV-fromBundle.ts:1247, :1271, :143). */
+function checkSlotPlaces(slots, { node, rulesApi, report }) {
+    for (const { element, name, path } of slots) {
+        const value = rulesApi.getAttributeValue(node, name);
+        const place = getPartPlace(path);
+        if (name === ELEMENT_PROPS ? isPartPlaceWritable(place, value) : isAttributePlaceWritable(name, path, value))
+            continue;
+        const check = name === ELEMENT_PROPS ? 'element_props_slot_place' : 'attribute_slot_place';
+        const message = name === ELEMENT_PROPS
+            ? `${describe(node, rulesApi)} holds an element in elementProps at a place the import can't write back: put it at a plain data key of the inner part (${place.parts.at(-1) ?? 'partName'}: {content: <…/>}) (tracker CONV-parseJsx.ts:1571).`
+            : `${describe(node, rulesApi)} holds an element in '${name}' at a place the import can't write back: put it under plain-name keys, give each array item on the way its own string _id, and no . [ ] in keys (tracker CONV-parseJsx.ts:1532).`;
+        report({ check, loc: getLoc(element, rulesApi), message });
+    }
+}
+/** True when every key on the way is a plain name and the attribute has no ambiguous key. An element in `data` (`data={{ items: […] }}`) is read from inside it: its keys are its own, not `data`. */
+function isAttributePlaceWritable(name, path, value) {
+    if (!path)
+        return false;
+    const keys = name === 'data' ? path.slice(1) : path;
+    if (name === 'data' && (path[0].itemId !== undefined || keys.length === 0))
+        return false;
+    return keys.every(({ key }) => isPlainKey(key)) && !isAmbiguous(value);
+}
+/** The inner parts on the way (`elementProps` inside an entry opens the parts of that entry), as far as the path reads, and the steps inside the entry's data (or after the entry, when it has no data) down to the element. keys is null when the way has no such form. */
+function getPartPlace(path) {
+    const parts = [];
+    if (!path || path[0].itemId !== undefined)
+        return { parts, keys: null };
+    let rest = path.slice(1);
+    while (rest.length) {
+        const [part, step, ...more] = rest;
+        parts.push(part.key);
+        if (part.itemId !== undefined || !step)
+            return { parts, keys: null };
+        if (step.key === ELEMENT_PROPS && step.itemId === undefined) {
+            rest = more;
+            continue;
+        }
+        return { parts, keys: step.key === 'data' && step.itemId === undefined ? more : rest.slice(1) };
+    }
+    return { parts, keys: null };
+}
+/** True when the element sits at a data key of an inner part, under plain keys, with none of the entry's own keys (`slots`, `data`…) first or last, and the part names can be written. In a wrapper-shaped `data` (see isWrapperEntry) the keys after the wrapper's own `data` key are the ones judged. */
+function isPartPlaceWritable({ parts, keys }, value) {
+    if (!keys?.length || !parts.every(isPartName) || isAmbiguous(value))
+        return false;
+    const own = keys[0].key === 'data' && isWrapperEntry(value, parts) ? keys.slice(1) : keys;
+    return own.length > 0 && own.every(({ key }) => isPlainKey(key)) && !RESERVED_ENTRY_KEYS.includes(own[0].key) && !RESERVED_ENTRY_KEYS.includes(own.at(-1).key);
+}
+/** True when the entry's `data` could be a canonical wrapper: the parts of the DM converter's isCanonicalDataWrapper that do not need the part's component type (it also wants `type` to be `<ComponentType>.Data`): https://github.com/wix-private/document-management/blob/e1d9b91f44d7ea8d6c1203dbfd26ee58a7f7079f/document-management-jsx-converter/src/projectData.ts#L304-L321. The import tells it by that type (parseJsx.ts:544), which the lint does not know, so an element inside such a `data.data` is not reported: the converter may read it. */
+function isWrapperEntry(value, parts) {
+    let entry = value;
+    for (const [index, part] of parts.entries()) {
+        const holder = index === 0 ? entry : isRecord(entry) ? entry.elementProps : undefined;
+        entry = isRecord(holder) ? holder[part] : undefined;
+    }
+    const data = isRecord(entry) ? entry.data : undefined;
+    return isRecord(data) && typeof data.type === 'string' && data.type.endsWith('.Data') && (data.id === undefined || typeof data.id === 'string') && isRecord(data.data)
+        && Object.keys(data).every((key) => key === 'type' || key === 'id' || key === 'data');
+}
+/** Reports a component that holds a slot element in its attributes while its data is not an object: a string, number, boolean, array or null (CONV-fromBundle.ts:127). */
+function checkSlotOwnerData(slots, { node, rulesApi, report }) {
+    const first = slots.find(({ name }) => name !== ELEMENT_PROPS);
+    const data = rulesApi.getAttributeValue(node, 'data');
+    if (!first || data === undefined || isRecord(data))
+        return;
+    report({ check: 'slot_owner_data_object', loc: getLoc(node, rulesApi), message: `${describe(node, rulesApi)} holds a slot element (in '${first.name}'), so its data must be an object: write data={{…}} or leave data out, not data={${JSON.stringify(data)}} (tracker CONV-fromBundle.ts:127).` });
+}
+const isPartName = (name) => PART_NAME.test(name) && !UNSAFE_PART_NAMES.has(name);
+const isPlainKey = (key) => DATA_KEY.test(key) && !RESERVED_KEYS.has(key);
+/** A key with . [ or ], or two array items with one `_id`, anywhere in the value: the import can't tell their paths apart (the DM converter's hasAmbiguousKey: https://github.com/wix-private/document-management/blob/e1d9b91f44d7ea8d6c1203dbfd26ee58a7f7079f/document-management-jsx-converter/src/slots.ts#L188-L199). */
+function isAmbiguous(value) {
+    if (Array.isArray(value)) {
+        const ids = value.map((item) => (isRecord(item) ? item._id : undefined)).filter((id) => typeof id === 'string');
+        return new Set(ids).size !== ids.length || value.some(isAmbiguous);
+    }
+    return isRecord(value) && Object.entries(value).some(([key, inner]) => /[.[\]]/.test(key) || isAmbiguous(inner));
+}
+/** Where to mark an element: its id attribute, or its tag name. */
+const getLoc = (element, rulesApi) => rulesApi.getComponent(element)?.loc ?? element.openingElement.name.loc;
+/** '<Slideshow> comp-2', or '<Top>' without an id. */
+function describe(element, rulesApi) {
+    const id = rulesApi.getId(element);
+    return `<${rulesApi.getTagName(element)}>${id ? ` ${id}` : ''}`;
+}

package/dist/rules-api/index.js

@@ -1,6 +1,6 @@
 // Part 3 — rules API: one linted file's page and the functions over it, and how a rule reports.
 export { createRulesApi, getOrCreateRulesApi } from "./rules-api.js";
 export { createCssFileReporter, describeAtRule, reportCssProblem } from "./report.js";
-export { bare, getAttribute, getExpression, getKey, getName, getObject, getProperties, getCallbackKind, getParamReadKind, getProperty, isBound, isOneEditAway, isReservedAttribute, isStructure, ownerOf, } from "../shared/utils.js";
-export { BUILDERS, CALLBACK_PROP, DATA_KEY, EVENT_ATTRIBUTE, GLOBAL_SECTIONS, INSTANCE_PROPS, LAYER_ATTRIBUTES, RESERVED_ATTRIBUTES, RESERVED_ENTRY_KEYS, RUNTIME_ONLY_BUILDERS, RUNTIME_PACKAGE, SECTIONS, SHARED_COMP_ID, STRUCTURE, SYSTEM_PACKAGE, TRANSFORM_BUILDERS, TYPED_BUILDERS, WRAPPERS, } from "../shared/constants.js";
+export { bare, getAttribute, getExpression, getKey, getName, getObject, getProperties, getCallbackKind, getParamReadKind, getProperty, isBound, isOneEditAway, isRecord, isReservedAttribute, isStructure, isReadByImport, ownerOf, } from "../shared/utils.js";
+export { BUILDERS, CALLBACK_PROP, DATA_KEY, ELEMENT_PROPS, EVENT_ATTRIBUTE, GLOBAL_SECTIONS, INSTANCE_PROPS, LAYER_ATTRIBUTES, RESERVED_ATTRIBUTES, RESERVED_ENTRY_KEYS, RUNTIME_ONLY_BUILDERS, RUNTIME_PACKAGE, SECTIONS, SHARED_COMP_ID, STRUCTURE, SYSTEM_PACKAGE, TRANSFORM_BUILDERS, TYPED_BUILDERS, WRAPPERS, } from "../shared/constants.js";
 export { BREAKPOINT_AT_RULES, CONTENT_TARGET, getCssChildren, getDashedId, getMixinId, getSegmentClass, getSelectorSegments, isCssIdentifier, isPresetProperty, isSafeCssIdentifier, ORIGAMI_TARGETS, OVERFLOW_TARGET, PREAMBLE_LAYER, readSegment } from "../shared/css.js";

package/dist/rules-api/rules-api.js

@@ -5,7 +5,7 @@ import path from 'node:path';
 import { GLOBAL_COMPONENTS_FOLDER } from "../shared/site-files-tree-mapping.js";
 import { models, pageId } from "../bi/stats.js";
 import { readPage } from "../page-model/index.js";
-import { getAttributeElements as getHeldElements, getChildren, getId, getImport, getImportKind, getImportedName, getPropNames, getSlot, getTagName, getType, hasDataAttributes, isTypeScript } from "../shared/utils.js";
+import { getAttributeElements as getHeldElements, getAttributeValue, getChildren, getId, getImport, getImportKind, getImportedName, getPropNames, getSlot, getTagName, getType, hasDataAttributes, isTypeScript } from "../shared/utils.js";
 import { readBreakpointName, readCustomMedia, readThemeTokens } from "../shared/css.js";
 import { WRAPPERS } from "../shared/constants.js";
 import { getEnclosingAtRules, isBaseDeclaration } from "./utils.js";
@@ -25,7 +25,7 @@ export function createRulesApi(page) {
             return [];
         return isWrapper(child) ? getChildElements(child) : [child];
     });
-    const getAttributeElements = (node) => getHeldElements(node).flatMap(({ element, attribute }) => (isWrapper(element) ? getChildElements(element).map((inner) => ({ element: inner, attribute })) : [{ element, attribute }]));
+    const getAttributeElements = (node) => getHeldElements(node).flatMap((held) => (isWrapper(held.element) ? getChildElements(held.element).map((inner) => ({ ...held, element: inner })) : [held]));
     return {
         page,
         // A JSX element starts where its component starts.
@@ -44,6 +44,7 @@ export function createRulesApi(page) {
         getChildren,
         getChildElements,
         getAttributeElements,
+        getAttributeValue,
         getSlot,
         getImport: (node) => getImport(node.type === 'JSXElement' ? getTagName(node).split('.')[0] : node.name, getProgram(node)),
         hasDataAttributes: (node) => hasDataAttributes(node, getProgram(node)),

package/dist/shared/constants.js

@@ -39,3 +39,5 @@ export const EVENT_ATTRIBUTE = /^on/i;
 export const CALLBACK_PROP = /^on[A-Z]/;
 /** By import source; the wrappers also by the imported name, since their packages export other things (`Show`, `Interact`). */
 export const LAYER_ATTRIBUTES = ['backgroundLayer', 'pinnedLayer'];
+/** The attribute that holds the elements of a component's inner parts: `elementProps={{ panel: { content: <X /> } }}`. */
+export const ELEMENT_PROPS = 'elementProps';

package/dist/shared/utils.js

@@ -89,20 +89,66 @@ export function getId(element) {
 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. */
-/** 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. */
+/** 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, its name, and its path: the name, then a step per object key down to the element; an array item's `_id` goes on the step of the key that holds the array. Not its children, and not the elements inside those elements.
+ *  path is null when the way has no such spelling: a computed key, an array item that isn't an object with a string `_id`, an element directly in an array. */
 export function getAttributeElements(owner) {
-    const elementsIn = (value) => {
+    const elementsIn = (written, path) => {
+        const value = written && bare(written);
         switch (value?.type) {
-            case 'JSXElement': return [value];
-            case 'JSXExpressionContainer': return elementsIn(value.expression);
-            case 'ObjectExpression': return value.properties.flatMap((property) => (property.type === 'Property' ? elementsIn(property.value) : []));
-            case 'ArrayExpression': return value.elements.flatMap(elementsIn);
+            case 'JSXElement': return [{ element: value, path }];
+            case 'JSXExpressionContainer': return elementsIn(value.expression, path);
+            case 'ObjectExpression': return value.properties.flatMap((property) => {
+                const key = getKeyName(property);
+                return property.type === 'Property' ? elementsIn(property.value, path && key !== null ? [...path, { key }] : null) : [];
+            });
+            case 'ArrayExpression': return value.elements.flatMap((item) => {
+                const itemId = getItemId(item);
+                return elementsIn(item, path && itemId !== null ? [...path.slice(0, -1), { key: path.at(-1).key, itemId }] : null);
+            });
             default: return [];
         }
     };
-    return owner.openingElement.attributes.filter(isAttribute).flatMap((attribute) => elementsIn(attribute.value).map((element) => ({ element, attribute: attribute })));
+    return owner.openingElement.attributes.filter(isAttribute).flatMap((attribute) => {
+        const name = getAttributeName(attribute);
+        return elementsIn(attribute.value, [{ key: name }]).map(({ element, path }) => ({ element, attribute: attribute, name, path }));
+    });
+}
+/** An attribute's value as plain data: literals (including a negative number such as `-1`), objects and arrays. undefined for what has no known value (no such attribute, an element, a variable, a call); inside an object or array such a value stays as undefined in its place. A computed key and a spread are left out. */
+export function getAttributeValue(owner, name) {
+    const attribute = owner.openingElement.attributes.filter(isAttribute).find((candidate) => getAttributeName(candidate) === name);
+    const valueOf = (written) => {
+        const value = written && bare(written);
+        switch (value?.type) {
+            case 'Literal': return value.value instanceof RegExp ? undefined : typeof value.value === 'bigint' ? Number(value.value) : value.value;
+            case 'JSXExpressionContainer': return valueOf(value.expression);
+            case 'UnaryExpression': {
+                const argument = value.argument && bare(value.argument);
+                const number = value.operator === '-' && argument?.type === 'Literal' ? valueOf(argument) : undefined;
+                return typeof number === 'number' ? -number : undefined;
+            }
+            case 'ObjectExpression': return Object.fromEntries(value.properties.flatMap((property) => {
+                const key = getKeyName(property);
+                return property.type === 'Property' && key !== null ? [[key, valueOf(property.value)]] : [];
+            }));
+            case 'ArrayExpression': return value.elements.map(valueOf);
+            default: return undefined;
+        }
+    };
+    return valueOf(attribute?.value);
 }
+/** `a`, `'a'` → 'a'; a computed key, or one that isn't a name or a string → null. */
+const getKeyName = (property) => property.computed || !property.key ? null : property.key.type === 'Identifier' ? (property.key.name ?? null) : property.key.type === 'Literal' && typeof property.key.value === 'string' ? property.key.value : null;
+/** The string `_id` of an array item that is an object with one (parentheses allowed around the item and the id); null for any other item. */
+const getItemId = (written) => {
+    const item = written && bare(written);
+    if (item?.type !== 'ObjectExpression')
+        return null;
+    const writtenId = item.properties.find((property) => property.type === 'Property' && getKeyName(property) === '_id')?.value;
+    const id = writtenId && bare(writtenId);
+    return id?.type === 'Literal' && typeof id.value === 'string' ? id.value : null;
+};
+/** `content`, or `xlink:href` for a namespaced name. */
+const getAttributeName = (attribute) => (attribute.name.type === 'JSXNamespacedName' ? `${attribute.name.namespace.name}:${attribute.name.name.name}` : attribute.name.name);
 /** Elements, text and {expressions}, in order. Whitespace and JSX comments are skipped. */
 export function getChildren(element) {
     return element.children.filter((child) => {
@@ -151,6 +197,17 @@ 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 import reads the element: it is not inside a function other than Structure or a renderItem template, a call, a condition, or an {expression} child. */
+export function isReadByImport(element) {
+    for (let up = element.parent; up.type !== 'JSXElement' && up.type !== 'Program'; up = up.parent) {
+        if (up.type === 'ArrowFunctionExpression')
+            return isStructure(up) || getCallbackKind(up) === 'template';
+        if (NOT_READ_IN.includes(up.type) || (up.type === 'JSXExpressionContainer' && up.parent.type !== 'JSXAttribute'))
+            return false;
+    }
+    return true;
+}
+const NOT_READ_IN = ['FunctionExpression', 'CallExpression', 'ConditionalExpression', 'LogicalExpression'];
 /** 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;
@@ -237,6 +294,7 @@ export function getPropNames(fn) {
         return null;
     return (param.properties ?? []).map(({ type, computed, key, value }) => type === 'Property' && !computed && key?.type === 'Identifier' && value?.type === 'Identifier' && value.name === key.name ? String(key.name) : null);
 }
+export const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const isImport = (statement) => statement.type === 'ImportDeclaration';
 const isAttribute = (attribute) => attribute.type === 'JSXAttribute';
 const isIdAttribute = (attribute) => isAttribute(attribute) && attribute.name.type === 'JSXIdentifier' && attribute.name.name === 'id';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-lint",
-  "version": "1.34.22",
+  "version": "1.34.24",
   "description": "Offline lint for an exported Origami site: lints the pages that changed since the last passing run",
   "type": "module",
   "bin": {
@@ -25,7 +25,7 @@
     "oxc-parser": "^0.151.0",
     "oxlint": "^1.39.0",
     "postcss": "^8.5.3",
-    "@wix/origami-bi": "0.11.0"
+    "@wix/origami-bi": "0.12.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -52,5 +52,5 @@
       ]
     }
   },
-  "falconPackageHash": "1837a281f36b5802f5c7a2d6ebb74b8c10661be0bc7a58f66c923836"
+  "falconPackageHash": "1bb53e289c65cf4acdcbc54a85fcf823b282d0e1be7bac656dff5170"
 }