@wix/origami-lint 0.0.0-stage → 1.34.2

package/dist/rules/data-values.js

@@ -0,0 +1,511 @@
+// The "data-values" subject of the converter rules (converter 0.80 at c8ed79b): astValue.ts 99, 123, 133; parseJsx.ts 915, 1223,
+// 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, GLOBAL_SECTIONS, RESERVED_ATTRIBUTES, RESERVED_ENTRY_KEYS, SHARED_COMP_ID, bare, getAttribute, getExpression, getKey, getName, getProperties, getProperty, isOneEditAway, isStructure, ownerOf, } from "../rules-api/index.js";
+import { defineRule } from "./define-rule.js";
+/** 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. */
+const EXCLUDED_DATA_KEYS = [
+    '_slotsId', '_mapId', 'hidden', 'class', 'title', 'role', 'tabindex', 'draggable', 'lang', 'dir', 'accesskey', 'contenteditable', 'spellcheck',
+    'translate', 'autofocus', 'inputmode', 'enterkeyhint', 'popover', 'inert', 'part', 'nonce', 'is', 'itemscope', 'itemtype', 'itemprop', 'itemid',
+    'itemref', 'tabIndex', 'contentEditable', 'accessKey', 'autoFocus', 'inputMode', 'enterKeyHint', 'spellCheck', 'children', 'styleRef', 'key',
+    'ref', ['dangerouslySet', 'InnerHTML'].join(''), '__proto__', 'constructor', 'prototype',
+];
+/** An elementProps entry's name is a CSS identifier (parseJsx.ts 1231): it becomes a class. */
+const CSS_IDENTIFIER = /^-?[_a-zA-Z]+[_a-zA-Z0-9-]*$/;
+/** Keys no object the import reads may have. */
+const RESERVED_OBJECT_KEYS = ['__proto__', 'constructor', 'prototype'];
+/** An image object's `type` (enrichImage.ts). */
+const IMAGE_TYPE = 'Builder.Image';
+/** The media identifiers the export writes: an image's (`wix:image://v1/<uri>/<name>#originWidth=…`), a document's (`wix:document://v1/ugd/<file>/<name>`). */
+const IMAGE_PREFIX = 'wix:image://v1/';
+const DOCUMENT_PREFIX = 'wix:document://v1/';
+/** The reserved attributes this rule reads as data. The strings are component-attributes', `className` and `bindings` the bindings rule's. */
+const READ_AS_DATA = ['data', 'props', 'elementProps'];
+const FULL = { menus: true, media: true, jsx: true };
+const PROPS = { menus: true, media: true };
+const PLAIN = {};
+const IMAGE_URL = 'getCroppedImageUrl';
+const DOCUMENT_URL = 'getDocumentUrl';
+const DOCUMENT_DIRECTORY = /\/(archives|ugd)\//;
+const LINK_KEYS = ['href', 'target', 'rel', 'pageRole'];
+const WRAPPER_KEYS = ['type', 'id', 'data'];
+const LITERAL_HINT = 'The import reads it as data: write the value itself, a string, a number, true / false, null, or an object or array of these.';
+export default defineRule({
+    name: 'data-values',
+    editors: ['studio2'],
+    callbacks: {
+        JSXElement: checkJSXElementDataValues,
+    },
+});
+// ── 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))
+        return;
+    const elementProps = getAttribute(input.node, 'elementProps');
+    const keysOnce = !elementProps || checkEntryKeysOnce(input, elementProps);
+    // an attribute with a value the import can't read stops there: nothing is built from it
+    const read = checkValuesAreLiterals(input, keysOnce ? [] : ['elementProps']);
+    if (elementProps && read.has('elementProps'))
+        checkElementPropsShape(input, elementProps);
+    checkDataKeyOnce(input, read.has('data') ? checkDataCarrier(input) : null);
+    checkDocumentLinks(input, read);
+    checkImageUrls(input, read);
+}
+// ── the steps ──
+const say = ({ report }, node, message) => report({ loc: node.loc, message });
+const textOf = ({ context }) => (node) => context.sourceCode.getText(node);
+const owner = ({ node }) => ownerOf(node);
+function checkValuesAreLiterals(input, skip) {
+    const read = new Set();
+    for (const attribute of getAttributes(input.node)) {
+        const name = getName(attribute);
+        if (READ_AS_DATA.includes(name) && attribute.value?.type !== 'JSXExpressionContainer') {
+            say(input, attribute, `\`${name}\` on ${owner(input)} isn't in braces. The import reads it only from braces: write \`${name}={…}\`.`);
+            continue;
+        }
+        const value = getExpression(attribute);
+        if (!value || skip.includes(name) || (isReserved(name) && !READ_AS_DATA.includes(name)))
+            continue;
+        if (!isReserved(name) && (isExcluded(name) || nearMissOf(name) || value.type === 'CallExpression'))
+            continue;
+        const mode = name === 'props' ? PROPS : FULL;
+        const found = name === 'elementProps' ? nonLiteralInElementProps(value, mode, input.rulesApi, textOf(input)) : nonLiteralIn(value, mode, input.rulesApi, textOf(input));
+        if (found)
+            say(input, found.node, `\`${name}\` on ${owner(input)} holds ${found.what}. ${LITERAL_HINT}`);
+        else
+            read.add(name);
+    }
+    return read;
+}
+function checkEntryKeysOnce(input, attribute) {
+    for (const { entry, path } of getEntries(getObject(getExpression(attribute)))) {
+        const seen = new Set();
+        for (const property of getProperties(entry)) {
+            const key = getKey(property);
+            if (key === null)
+                continue;
+            if (seen.has(key)) {
+                say(input, property, `${owner(input)}'s elementProps entry \`${path.join('.')}\` has the key \`${key}\` twice. Keep one.`);
+                return false;
+            }
+            seen.add(key);
+        }
+    }
+    return true;
+}
+function checkElementPropsShape(input, attribute) {
+    const value = getExpression(attribute);
+    // an object written out: a media call decodes to an object, but its keys aren't inner parts
+    const map = getObject(value);
+    if (!map)
+        return say(input, value, `\`elementProps\` on ${owner(input)} isn't an object. Write an object of inner parts: \`elementProps={{ name: {…} }}\`.`);
+    checkElementPropsEntries(input, map, []);
+}
+function checkElementPropsEntries(input, map, path) {
+    for (const property of getProperties(map)) {
+        const name = getKey(property);
+        const at = [...path, name].join('.');
+        if (!checkEntryName(input, property, name) || builderOf(bare(property.value), input.rulesApi))
+            continue;
+        // an object written out: a media call decodes to an object, but not to an inner part's settings
+        const entry = getObject(property.value);
+        if (!entry) {
+            say(input, property.value, `${owner(input)}'s elementProps entry \`${at}\` isn't an object. Write the inner part's settings as an object: \`${name}: {…}\`.`);
+            continue;
+        }
+        checkEntryKeysAreKnown(input, entry, at);
+        const data = getProperty(entry, 'data');
+        if (data && !isObjectValue(data.value, input.rulesApi))
+            say(input, data.value, `${owner(input)}'s elementProps entry \`${at}\` has \`data\` that isn't an object. Write \`data: {…}\`.`);
+        const nested = getProperty(entry, 'elementProps');
+        if (!nested)
+            continue;
+        const nestedMap = getObject(nested.value);
+        if (!nestedMap)
+            say(input, nested.value, `${owner(input)}'s elementProps entry \`${at}\` has \`elementProps\` that isn't an object. Write \`elementProps: { name: {…} }\`.`);
+        else
+            checkElementPropsEntries(input, nestedMap, [...path, name]);
+    }
+}
+function checkEntryName(input, property, name) {
+    const what = name === '' ? 'an empty name' : name.includes('|') ? `the name \`${name}\`, which has a \`|\`` : !CSS_IDENTIFIER.test(name) || RESERVED_OBJECT_KEYS.includes(name) ? `the name \`${name}\`, which isn't a CSS identifier` : null;
+    if (what)
+        say(input, property.key, `${owner(input)} has an elementProps entry with ${what}. Name it as the inner part is named, like \`navbar\`.`);
+    return what === null;
+}
+function checkEntryKeysAreKnown(input, entry, at) {
+    for (const property of getProperties(entry)) {
+        const key = getKey(property);
+        if (key === null || key === '_id' || RESERVED_ENTRY_KEYS.includes(key) || bare(property.value).type === 'CallExpression')
+            continue;
+        const typo = nearMissOf(key);
+        if (!isReserved(key) && !isExcluded(key) && !typo)
+            continue;
+        say(input, property.key, `${owner(input)}'s elementProps entry \`${at}\` has the key \`${key}\`, which an inner part doesn't take. Use its data keys, or \`data: {…}\`${typo ? ` (did you mean \`${typo}\`?)` : ''}.`);
+    }
+}
+function checkDataCarrier(input) {
+    const data = getAttribute(input.node, 'data');
+    const value = getExpression(data);
+    if (!value)
+        return null;
+    const merges = dataAttributes(input).length > 0 || (takesData(input) && getAttribute(input.node, '_id') !== undefined);
+    if (!merges)
+        return null;
+    if (!isObjectValue(value, input.rulesApi)) {
+        say(input, value, `${owner(input)} has data attributes, so its \`data\` must be an object: \`data={{…}}\`, not \`data={${textOf(input)(value)}}\`.`);
+        return null;
+    }
+    const carrier = getObject(value);
+    if (carrier && isWrapper(input, carrier)) {
+        say(input, data, `${owner(input)} mixes data attributes with the \`{ type, data }\` wrapper in \`data={…}\`. Move the wrapper's keys to attributes.`);
+        return null;
+    }
+    return carrier;
+}
+function isWrapper(input, carrier) {
+    const keys = getProperties(carrier).map(getKey);
+    if (keys.length !== carrier.properties.length || !keys.every((key) => key !== null && WRAPPER_KEYS.includes(key)))
+        return false;
+    const type = valueOf(getProperty(carrier, 'type')?.value ?? null);
+    const id = getProperty(carrier, 'id');
+    const name = componentNameOf(input);
+    return typeof type === 'string' && (type === `${name}.Data` || type.endsWith(`.${name}.Data`))
+        && getObject(getProperty(carrier, 'data')?.value) !== null && (!id || typeof valueOf(id.value) === 'string');
+}
+function checkDataKeyOnce(input, carrier) {
+    if (carrier) {
+        const keys = new Set(getProperties(carrier).map(getKey));
+        const attributes = [...dataAttributes(input), getAttribute(input.node, '_id')].filter((attribute) => attribute !== undefined);
+        for (const attribute of attributes) {
+            const name = getName(attribute);
+            if (keys.has(name))
+                say(input, attribute, `${owner(input)} has \`${name}\` both as an attribute and inside \`data={{…}}\`. Keep only one.`);
+        }
+    }
+    for (const { entry, path } of getEntries(getObject(getExpression(getAttribute(input.node, 'elementProps'))))) {
+        const data = getObject(getProperty(entry, 'data')?.value);
+        if (!data)
+            continue;
+        const keys = new Set(getProperties(data).map(getKey));
+        for (const property of entryDataKeys(entry)) {
+            const key = getKey(property);
+            if (keys.has(key))
+                say(input, property, `${owner(input)}'s elementProps entry \`${path.join('.')}\` has \`${key}\` both as a key and inside its \`data\`. Keep only one.`);
+        }
+    }
+}
+/** Not in `data` or an entry's `data`: the import stores them as they are. */
+function checkDocumentLinks(input, read) {
+    const values = dataAttributes(input).filter((attribute) => read.has(getName(attribute))).map((attribute) => getExpression(attribute)).filter(Boolean);
+    const elementProps = read.has('elementProps') ? getExpression(getAttribute(input.node, 'elementProps')) : null;
+    for (const { entry } of getEntries(getObject(elementProps))) {
+        values.push(...entryDataKeys(entry).filter((property) => getKey(property) !== '_id').map((property) => property.value));
+    }
+    for (const value of values)
+        for (const link of linksIn(value, input))
+            checkDocumentHref(input, link);
+}
+function linksIn(node, input) {
+    const value = bare(node);
+    if (value.type === 'ArrayExpression')
+        return value.elements.flatMap((element) => (element && element.type !== 'SpreadElement' ? linksIn(element, input) : []));
+    if (value.type !== 'ObjectExpression')
+        return [];
+    if (isLink(value, input))
+        return [value];
+    return getProperties(value).flatMap((property) => linksIn(property.value, input));
+}
+function isLink(object, input) {
+    const properties = getProperties(object);
+    if (properties.length !== object.properties.length || !properties.every((property) => LINK_KEYS.includes(getKey(property) ?? '')))
+        return false;
+    const href = getProperty(object, 'href')?.value;
+    return href !== undefined && (typeof valueOf(href) === 'string' || documentIdentifierOf(bare(href), input.rulesApi) !== null);
+}
+function checkDocumentHref(input, link) {
+    const href = getProperty(link, 'href');
+    const bareHref = valueOf(href.value);
+    if (typeof bareHref === 'string') {
+        if (bareHref.startsWith(DOCUMENT_PREFIX))
+            say(input, href, `${owner(input)}'s link href is a bare 'wix:document://' string. Write \`href: media.getDocumentUrl('wix:document://…').url\`, with media imported from '@wix/sdk'.`);
+        return;
+    }
+    const identifier = documentIdentifierOf(bare(href.value), input.rulesApi);
+    if (!hasDocumentId(identifier))
+        say(input, href, `${owner(input)}'s document link has no document id in '${identifier}'. Use the identifier the export wrote: \`media.getDocumentUrl('wix:document://v1/ugd/<file>/<name>').url\`.`);
+}
+/** documentLink.ts rebuildDocumentLink: the first `/ugd/` or `/archives/` goes, then `<id>/<name>`; the name is URI-decoded. */
+function hasDocumentId(identifier) {
+    const [id, name = ''] = identifier.replace(DOCUMENT_DIRECTORY, '/').slice(DOCUMENT_PREFIX.length).split('/');
+    try {
+        decodeURIComponent(name);
+    }
+    catch {
+        return false;
+    }
+    return id !== '';
+}
+function checkImageUrls(input, read) {
+    const urls = new Set();
+    const values = dataValues(input).filter(([, path]) => read.has(attributeOf(path)));
+    for (const [value, path] of values) {
+        for (const { node, path: at } of objectsIn(value, path)) {
+            if (valueOf(getProperty(node, 'type')?.value ?? null) !== IMAGE_TYPE)
+                continue;
+            const url = getProperty(node, 'url');
+            if (!url)
+                continue;
+            urls.add(bare(url.value));
+            const fields = valueOf({ ...node, properties: getProperties(node).filter((property) => property !== url) });
+            if (!isValue(fields))
+                continue;
+            const call = bare(url.value);
+            if (isImageCall(call, input.rulesApi) && sameArguments(call, derivedImageArguments(fields)))
+                continue;
+            say(input, url, `${owner(input)}'s \`${at}.url\` isn't the url the image's fields give. It is derived: change the image's uri, width, height, name or crop, and drop \`url\`.`);
+        }
+    }
+    const stray = imageCallsIn(input, values, read).find((call) => !urls.has(call));
+    if (stray)
+        say(input, stray, `${owner(input)} has \`media.getCroppedImageUrl(…)\` outside an image's url. Write it only as the \`url\` of a \`{ type: 'Builder.Image', … }\` object.`);
+}
+function imageCallsIn(input, dataValuesRead, read) {
+    const values = dataValuesRead.map(([value]) => value);
+    const props = read.has('props') ? getExpression(getAttribute(input.node, 'props')) : null;
+    if (props)
+        values.push(props);
+    const calls = (node) => {
+        if (node === null)
+            return [];
+        const value = bare(node);
+        if (isMediaCall(value, 'getCroppedImageUrl', input.rulesApi))
+            return isImageCall(value, input.rulesApi) && value.arguments.every((argument) => isValue(valueOf(argument))) ? [value] : [];
+        if (value.type === 'ArrayExpression')
+            return value.elements.flatMap((element) => (element && element.type !== 'SpreadElement' ? calls(element) : []));
+        if (value.type === 'ObjectExpression')
+            return getProperties(value).flatMap((property) => (builderOf(bare(property.value), input.rulesApi) ? [] : calls(property.value)));
+        return [];
+    };
+    return values.flatMap(calls);
+}
+// ── reading the code ──
+const getAttributes = (element) => element.openingElement.attributes.filter((attribute) => attribute.type === 'JSXAttribute');
+const getObject = (node) => (node && bare(node).type === 'ObjectExpression' ? bare(node) : 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: a builder component (its import gives a componentType) takes data attributes; the `type` attr is gone. */
+function takesData({ node, rulesApi }) {
+    const found = rulesApi.getImport(node);
+    const type = rulesApi.getType(node);
+    return found !== null && found.kind !== 'core' && !found.source.startsWith('.') && !(type && NO_DATA_TYPES.includes(type));
+}
+/** The name the import gives the tag's component (parseJsx.ts namedImportOf): the imported name, else the tag's own (`<Box>`, `<ui.Box>`). */
+function componentNameOf({ node, rulesApi }) {
+    const imported = rulesApi.getImport(node)?.imported;
+    return imported && imported !== 'default' && imported !== '*' ? imported : rulesApi.getTagName(node).split('.').at(-1);
+}
+/** Not the component's data: the converter's reserved attributes, and `sharedCompId`. */
+const isReserved = (name) => RESERVED_ATTRIBUTES.includes(name) || name === SHARED_COMP_ID;
+const isDataName = (name) => !isReserved(name) && !isExcluded(name) && nearMissOf(name) === undefined;
+const isExcluded = (name) => EXCLUDED_DATA_KEYS.includes(name) || name.startsWith('data-') || name.startsWith('aria-') || /^on/i.test(name) || !DATA_KEY.test(name);
+const nearMissOf = (name) => RESERVED_ATTRIBUTES.find((target) => isOneEditAway(name, target));
+const dataAttributes = (input) => !takesData(input) ? [] : getAttributes(input.node).filter((attribute) => isDataName(getName(attribute)) && getExpression(attribute)?.type !== 'CallExpression');
+const entryDataKeys = (entry) => getProperties(entry).filter((property) => getKey(property) !== null && !RESERVED_ENTRY_KEYS.includes(getKey(property)) && bare(property.value).type !== 'CallExpression');
+/** The attribute a data value's path starts at: `data.x` → `data`, `elementProps.nav.label` → `elementProps`. */
+const attributeOf = (path) => path.split('.')[0];
+function getEntries(map, path = []) {
+    if (!map)
+        return [];
+    return getProperties(map).flatMap((property) => {
+        const key = getKey(property);
+        const entry = getObject(property.value);
+        if (key === null || !entry)
+            return [];
+        const at = [...path, key];
+        return [{ entry, path: at }, ...getEntries(getObject(getProperty(entry, 'elementProps')?.value), at)];
+    });
+}
+const isProperty = (node, name) => node.type === 'MemberExpression' && !node.computed && !node.optional && node.property.type === 'Identifier' && node.property.name === name;
+const isImportedAs = (node, rulesApi, kind, imported) => {
+    if (node.type !== 'Identifier')
+        return false;
+    const found = rulesApi.getImport(node);
+    return found?.kind === kind && (imported === undefined || found.imported === imported);
+};
+function isMediaCall(node, method, rulesApi) {
+    if (node.type !== 'CallExpression' || node.optional || node.callee.type !== 'MemberExpression' || !isProperty(node.callee, method))
+        return false;
+    return isImportedAs(node.callee.object, rulesApi, 'sdk', 'media');
+}
+function isImageCall(node, rulesApi) {
+    if (!isMediaCall(node, IMAGE_URL, rulesApi) || node.arguments.length !== 8)
+        return false;
+    const id = valueOf(node.arguments[0]);
+    return typeof id === 'string' && id.startsWith(IMAGE_PREFIX);
+}
+function documentIdentifierOf(node, rulesApi) {
+    if (!isProperty(node, 'url') || node.type !== 'MemberExpression')
+        return null;
+    const call = node.object;
+    if (!isMediaCall(call, DOCUMENT_URL, rulesApi) || call.arguments.length !== 1)
+        return null;
+    const identifier = valueOf(call.arguments[0]);
+    return typeof identifier === 'string' && identifier.startsWith(DOCUMENT_PREFIX) ? identifier : null;
+}
+/** What `x` decodes to is an object: an object written out, or a media call (the import keeps it as an object). */
+const isObjectValue = (node, rulesApi) => bare(node).type === 'ObjectExpression' || isImageCall(bare(node), rulesApi) || documentIdentifierOf(bare(node), rulesApi) !== null;
+function builderOf(node, rulesApi) {
+    return node.type === 'CallExpression' && node.callee.type === 'Identifier' && rulesApi.getImport(node.callee)?.kind === 'runtime';
+}
+function nonLiteralIn(node, mode, rulesApi, getText, path = '') {
+    if (node === null)
+        return null;
+    const value = bare(node);
+    switch (value.type) {
+        case 'Literal':
+            return ['string', 'number', 'boolean'].includes(typeof value.value) || value.raw === 'null' ? null : { node: value, what: `\`${value.raw}\`, which isn't a string, number, true / false or null` };
+        case 'UnaryExpression':
+            return value.operator === '-' && value.argument.type === 'Literal' && typeof value.argument.value === 'number' ? null : { node: value, what: `\`${getText(value)}\`` };
+        case 'Identifier':
+            if (mode.menus && isImportedAs(value, rulesApi, 'menu'))
+                return null;
+            return { node: value, what: `the variable \`${value.name}\`` };
+        case 'MemberExpression':
+            if (mode.menus && isProperty(value, 'items') && isImportedAs(value.object, rulesApi, 'menu'))
+                return null;
+            if (mode.media && documentIdentifierOf(value, rulesApi) !== null)
+                return null;
+            return { node: value, what: `\`${getText(value)}\`` };
+        case 'CallExpression':
+            if (value.callee.type === 'Identifier')
+                return null;
+            if (mode.media && isImageCall(value, rulesApi))
+                return value.arguments.map((argument) => nonLiteralIn(argument, PLAIN, rulesApi, getText)).find(Boolean) ?? null;
+            return { node: value, what: `a call to \`${getText(value.callee)}\`` };
+        case 'JSXElement':
+            return mode.jsx ? null : { node: value, what: 'an element' };
+        case 'FunctionExpression':
+        case 'ArrowFunctionExpression':
+            return { node: value, what: 'a function' };
+        case 'TemplateLiteral':
+            return { node: value, what: `a template string (\`${getText(value)}\`)` };
+        case 'ArrayExpression':
+            if (value.elements.some((element) => element === null || element.type === 'SpreadElement'))
+                return { node: value, what: 'an array with a spread or an empty place (`[a, , b]`)' };
+            return value.elements.map((element) => nonLiteralIn(element, mode, rulesApi, getText)).find(Boolean) ?? null;
+        case 'ObjectExpression':
+            return nonLiteralInObject(value, mode, rulesApi, getText, path);
+        default:
+            return { node: value, what: `\`${getText(value)}\`` };
+    }
+}
+/** Each level is checked whole (its entries, then its keys once) before the values inside it, as the import does. */
+function nonLiteralInObject(object, mode, rulesApi, getText, path, readValue) {
+    const keys = new Set();
+    for (const property of object.properties) {
+        if (property.type === 'SpreadElement')
+            return { node: property, what: `a spread (\`${getText(property)}\`)` };
+        if (property.computed || property.kind !== 'init')
+            return { node: property, what: `\`${getText(property)}\`, which isn't a \`key: value\` entry` };
+        const key = getKey(property);
+        if (key === null)
+            return { node: property, what: `the key \`${getText(property.key)}\`, which isn't a name or a string` };
+        const dotted = path ? `${path}.${key}` : key;
+        if (keys.has(key))
+            return { node: property, what: `the key \`${dotted}\` twice` };
+        keys.add(key);
+    }
+    const read = readValue ?? ((property, at) => nonLiteralIn(property.value, mode, rulesApi, getText, at));
+    for (const property of getProperties(object)) {
+        const found = read(property, path ? `${path}.${getKey(property)}` : getKey(property));
+        if (found)
+            return found;
+    }
+    return null;
+}
+function nonLiteralInElementProps(node, mode, rulesApi, getText, path = '') {
+    const map = getObject(node);
+    if (!map)
+        return nonLiteralIn(node, mode, rulesApi, getText, path);
+    const readEntry = (property, at) => {
+        const key = getKey(property);
+        const value = bare(property.value);
+        if (key === 'bindings' || key === 'slots' || key === 'className' || (!RESERVED_ENTRY_KEYS.includes(key) && value.type === 'CallExpression'))
+            return null;
+        return key === 'elementProps' ? nonLiteralInElementProps(value, mode, rulesApi, getText, at) : nonLiteralIn(value, mode, rulesApi, getText, at);
+    };
+    return nonLiteralInObject(map, mode, rulesApi, getText, path, (property, at) => {
+        const entry = getObject(property.value);
+        return entry ? nonLiteralInObject(entry, mode, rulesApi, getText, at, readEntry) : nonLiteralIn(property.value, mode, rulesApi, getText, at);
+    });
+}
+const NOT_A_VALUE = Symbol('not a value');
+function valueOf(node) {
+    if (node === null)
+        return NOT_A_VALUE;
+    const value = bare(node);
+    if (value.type === 'Literal')
+        return value.raw === 'null' || ['string', 'number', 'boolean'].includes(typeof value.value) ? value.value : NOT_A_VALUE;
+    if (value.type === 'UnaryExpression')
+        return value.operator === '-' && value.argument.type === 'Literal' && typeof value.argument.value === 'number' ? -value.argument.value : NOT_A_VALUE;
+    if (value.type === 'ArrayExpression') {
+        const items = value.elements.map((element) => (element && element.type !== 'SpreadElement' ? valueOf(element) : NOT_A_VALUE));
+        return items.includes(NOT_A_VALUE) ? NOT_A_VALUE : items;
+    }
+    if (value.type !== 'ObjectExpression' || getProperties(value).length !== value.properties.length)
+        return NOT_A_VALUE;
+    const entries = getProperties(value).map((property) => [getKey(property), valueOf(property.value)]);
+    return entries.some(([key, item]) => key === null || item === NOT_A_VALUE) ? NOT_A_VALUE : Object.fromEntries(entries);
+}
+const isValue = (value) => value !== NOT_A_VALUE;
+/** The arguments the export writes for an image's url (build/image/imageExpression.ts derivedImageExpressionOf). */
+function derivedImageArguments(image) {
+    const { uri, name, crop } = image;
+    const width = image.width || 0;
+    const height = image.height || 0;
+    const id = uri ? `${IMAGE_PREFIX}${uri}${name ? `/${encodeURIComponent(name)}` : ''}#originWidth=${width}&originHeight=${height}` : undefined;
+    return [
+        id, crop?.x || 0, crop?.y || 0, crop?.width || 0, crop?.height || 0, crop?.width || width, crop?.height || height,
+        { ...(name !== undefined ? { name } : {}), autoEncode: true, devicePixelRatio: 1 },
+    ];
+}
+const sameArguments = (call, expected) => isDeepStrictEqual(call.arguments.map(valueOf), expected);
+function objectsIn(node, path) {
+    if (node === null)
+        return [];
+    const value = bare(node);
+    if (value.type === 'ArrayExpression')
+        return value.elements.flatMap((element, index) => (element && element.type !== 'SpreadElement' ? objectsIn(element, `${path}[${index}]`) : []));
+    if (value.type !== 'ObjectExpression')
+        return [];
+    return [{ node: value, path }, ...getProperties(value).flatMap((property) => objectsIn(property.value, `${path}.${getKey(property)}`))];
+}
+function dataValues(input) {
+    const element = input.node;
+    const values = dataAttributes(input).map((attribute) => [getExpression(attribute), getName(attribute)]).filter(([value]) => value);
+    const data = getExpression(getAttribute(element, 'data'));
+    if (data)
+        values.push([data, 'data']);
+    for (const { entry, path } of getEntries(getObject(getExpression(getAttribute(element, 'elementProps'))))) {
+        const at = `elementProps.${path.join('.')}`;
+        for (const property of entryDataKeys(entry))
+            values.push([property.value, `${at}.${getKey(property)}`]);
+        const entryData = getProperty(entry, 'data');
+        if (entryData)
+            values.push([entryData.value, `${at}.data`]);
+    }
+    return values;
+}
+function isWrittenOut(element) {
+    for (let up = element.parent; up.type !== 'JSXElement' && up.type !== 'Program'; up = up.parent) {
+        if (up.type === 'ArrowFunctionExpression')
+            return isStructure(up);
+        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/define-rule.js

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