@trypattern/sdk 0.0.0-stage → 0.1.1

package/dist/rules/lintPlugin.js

@@ -0,0 +1,1159 @@
+import { ACTIONS_WHERE_MESSAGE, COMPONENT_FIRST_MESSAGE, COMPONENT_FILE_NAME_MESSAGE, DARK_MODE_IN_TOKENS_MESSAGE, DEV_ONLY_SIGN_IN_MESSAGE, EXPLICIT_ACCESS_MESSAGE, USE_BREAKPOINTS_MESSAGE, HOVER_USES_HIGHLIGHT_MESSAGE, NO_CLASSNAME_STRINGS_MESSAGE, NO_COMMENTS_MESSAGE, NO_INTERACTIVE_TRANSITION_MESSAGE, NO_POINTER_CURSOR_MESSAGE, NO_ROUTE_DATA_APIS_MESSAGE, ROUTES_UNDER_APP_LAYOUT_MESSAGE, SCROLL_VIEW_ONLY_MESSAGE, SELECTABLE_ONLY_MESSAGE, STATE_VIA_HOOKS_MESSAGE, MODEL_BY_NAME_MESSAGE, MODEL_MEMBERS_MESSAGE, PURE_ACTIONS_MESSAGE, PURE_GETTERS_MESSAGE, USE_MODEL_WHERE_MESSAGE, CLASSES_NOT_FACTORIES_MESSAGE, STORES_IN_APP_MESSAGE, TYPED_STYLE_PROP_MESSAGE, USE_COLOR_TOKEN_MESSAGE, USE_FONT_TOKEN_MESSAGE, USE_LINK_MESSAGE, USE_PRIMITIVES_MESSAGE, NO_WIDGET_ROLES_MESSAGE, NO_CLICK_ON_STATIC_MESSAGE, PRIMITIVE_NAMES_MESSAGE, USE_SPACE_TOKENS_MESSAGE, USE_SIZE_TOKENS_MESSAGE, TEXT_VIA_TEXT_MESSAGE, TEXT_ELEMENTS_MESSAGE, LOOSE_TEXT_MESSAGE, COMPOSE_IN_SCREENS_MESSAGE, NO_HOVER_IN_APP_MESSAGE } from "./messages.js";
+const TOKENS_FILE = 'src/theme/tokens.stylex.ts';
+const APP_THEME_FILE = 'src/theme/theme.ts';
+const SCROLL_AREA_FILE = 'src/components/ScrollArea.tsx';
+const SELECTABLE_FILE = 'src/components/Text.tsx';
+const PRIMITIVE_ELEMENTS = new Set([
+    'button',
+    'input',
+    'textarea',
+    'select',
+    'dialog',
+    'progress',
+    'meter'
+]);
+const WIDGET_ROLES = new Set([
+    'button',
+    'switch',
+    'checkbox',
+    'radio',
+    'menu',
+    'menuitem',
+    'tooltip',
+    'dialog',
+    'slider',
+    'progressbar',
+    'separator',
+    'combobox',
+    'listbox',
+    'option'
+]);
+const STATIC_ELEMENTS = new Set([
+    'div',
+    'span',
+    'li',
+    'section',
+    'article',
+    'p'
+]);
+const CLICK_HANDLERS = new Set([
+    'onClick',
+    'onPointerDown',
+    'onMouseDown',
+    'onKeyDown'
+]);
+const PRIMITIVES = new Set([
+    'AppFrame',
+    'AppearancePicker',
+    'Avatar',
+    'Badge',
+    'Button',
+    'Card',
+    'CommandMenu',
+    'CommandPalette',
+    'Content',
+    'ContextMenu',
+    'Dialog',
+    'Divider',
+    'CopyButton',
+    'EmptyState',
+    'Form',
+    'Icon',
+    'IconButton',
+    'Kbd',
+    'Link',
+    'ListRow',
+    'LoadingRows',
+    'Menu',
+    'PropertyRow',
+    'RadioGroup',
+    'Row',
+    'Screen',
+    'ScrollArea',
+    'SegmentedControl',
+    'Select',
+    'SettingsRow',
+    'SignInScreen',
+    'Skeleton',
+    'Spinner',
+    'Stack',
+    'Switch',
+    'Text',
+    'TextField',
+    'Toaster',
+    'Tooltip'
+]);
+const SCREEN_FILE = /(^|\/)src\/(screens|layouts)\//;
+const STYLE_SOURCES = new Set([
+    '@stylexjs/stylex',
+    '@trypattern/sdk/tokens.stylex'
+]);
+const POINTER_CONDITIONS = new Set([
+    ':hover',
+    ':active',
+    ':focus',
+    ':focus-visible',
+    ':focus-within'
+]);
+const TEXT_PROPERTIES = new Set([
+    'font',
+    'fontSize',
+    'fontWeight',
+    'fontFamily',
+    'fontStyle',
+    'lineHeight',
+    'letterSpacing',
+    'textTransform',
+    'textAlign',
+    'textOverflow',
+    'textDecoration',
+    'whiteSpace'
+]);
+const TEXT_ELEMENTS = new Set([
+    'p',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'label',
+    'strong',
+    'em',
+    'small'
+]);
+const SPACING_PROPERTY = /^(padding|margin)(Block|Inline)?(Start|End)?$|^(gap|rowGap|columnGap)$/;
+const SIZE_PROPERTIES = new Set([
+    'height',
+    'minHeight',
+    'width',
+    'fontSize',
+    'lineHeight'
+]);
+const SPACING_TOKEN_GROUPS = new Set([
+    'space',
+    'controls',
+    'borders',
+    'lineHeights'
+]);
+const SIZE_TOKEN_GROUPS = new Set([
+    'controls',
+    'iconSizes',
+    'lineHeights',
+    'fontSizes',
+    'borders',
+    'space',
+    'widths'
+]);
+const SIZE_KEYWORDS = /^(auto|inherit|fit-content|max-content|min-content|\d+(\.\d+)?%|\d+(\.\d+)?v[hw]|var\(--[\w-]+\))$/;
+const ROUTES_FILE = 'src/routes.tsx';
+const COMPONENT_FILE = /src\/(components|screens|layouts)\/(?:[^/]+\/)*([^/]+)\.tsx$/;
+const COLOR_KEYWORDS = new Set([
+    'transparent',
+    'currentColor',
+    'currentcolor',
+    'inherit',
+    'initial',
+    'unset',
+    'revert',
+    'none'
+]);
+const RAW_COLOR = /#[0-9a-f]{3,8}\b|\b(rgba?|hsla?|hwb|lab|lch|oklab|oklch|color)\(/i;
+const FONT_PROPERTIES = new Set([
+    'fontSize',
+    'fontFamily',
+    'fontWeight',
+    'font'
+]);
+const INTERACTIVE_CONDITIONS = new Set([':hover', ':active']);
+const SELECTED_STYLE_NAME = /(active|selected|current)$/i;
+const SCROLLING_OVERFLOW_PROPERTIES = new Set([
+    'overflow',
+    'overflowX',
+    'overflowY',
+    'overflowBlock',
+    'overflowInline'
+]);
+const SERVER_FILE = /(^|\/)server\//;
+const STORE_IMPORT = /\/stores\//;
+const MAY_IMPORT_STORES = /src\/(App\.ts$|stores\/)/;
+const ROUTE_DATA_KEYS = new Set([
+    'loader',
+    'action',
+    'lazy',
+    'shouldRevalidate'
+]);
+function isNode(value) {
+    return typeof value === 'object' && value !== null && 'type' in value;
+}
+function child(node, key) {
+    const value = node[key];
+    return isNode(value) ? value : undefined;
+}
+function children(node, key) {
+    const value = node[key];
+    return Array.isArray(value) ? value.filter(isNode) : [];
+}
+function keyName(property) {
+    const key = child(property, 'key');
+    if (key === undefined)
+        return undefined;
+    if (key.type === 'Identifier' && property['computed'] !== true) {
+        return typeof key['name'] === 'string' ? key['name'] : undefined;
+    }
+    return typeof key['value'] === 'string' ? key['value'] : undefined;
+}
+function stringValue(node) {
+    return node.type === 'Literal' && typeof node['value'] === 'string'
+        ? node['value']
+        : undefined;
+}
+function isRawLiteral(node) {
+    return ((node.type === 'Literal' && node['value'] !== null) ||
+        node.type === 'TemplateLiteral');
+}
+function isMember(node, object, property) {
+    const target = child(node, 'object');
+    const name = child(node, 'property');
+    return (node.type === 'MemberExpression' &&
+        target?.type === 'Identifier' &&
+        target['name'] === object &&
+        name?.type === 'Identifier' &&
+        name['name'] === property);
+}
+function isButtonStateToken(node) {
+    const target = child(node, 'object');
+    const name = child(node, 'property');
+    return (node.type === 'MemberExpression' &&
+        target?.type === 'Identifier' &&
+        target['name'] === 'colors' &&
+        name?.type === 'Identifier' &&
+        typeof name['name'] === 'string' &&
+        (name['name'].endsWith('Hover') || name['name'].endsWith('Active')));
+}
+function walk(node, visit) {
+    visit(node);
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'parent')
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                if (isNode(item))
+                    walk(item, visit);
+        }
+        else if (isNode(value)) {
+            walk(value, visit);
+        }
+    }
+}
+function inFile(context, path) {
+    return context.filename.endsWith(path);
+}
+function isStylexCreate(node) {
+    const callee = child(node, 'callee');
+    return callee !== undefined && isMember(callee, 'stylex', 'create');
+}
+function flatten(styleName, property, value, conditions, location) {
+    if (value.type !== 'ObjectExpression') {
+        return [{ styleName, property, conditions, value, location }];
+    }
+    return children(value, 'properties').flatMap((condition) => {
+        const name = keyName(condition) ?? '[computed]';
+        const conditionValue = child(condition, 'value');
+        return conditionValue === undefined
+            ? []
+            : flatten(styleName, property, conditionValue, [...conditions, name], condition.loc);
+    });
+}
+function styleDeclarations(createCall) {
+    const [namespaces] = children(createCall, 'arguments');
+    if (namespaces?.type !== 'ObjectExpression')
+        return [];
+    return children(namespaces, 'properties').flatMap((namespace) => {
+        const styleName = keyName(namespace) ?? '';
+        const style = child(namespace, 'value');
+        if (style?.type !== 'ObjectExpression')
+            return [];
+        return children(style, 'properties').flatMap((declaration) => {
+            const property = keyName(declaration);
+            const value = child(declaration, 'value');
+            return property === undefined || value === undefined
+                ? []
+                : flatten(styleName, property, value, [], declaration.loc);
+        });
+    });
+}
+function styleRule(check) {
+    return {
+        meta: { type: 'problem' },
+        create(context) {
+            return {
+                CallExpression(node) {
+                    if (!isStylexCreate(node))
+                        return;
+                    for (const problem of check(styleDeclarations(node), context)) {
+                        context.report({ loc: problem.location, message: problem.message });
+                    }
+                }
+            };
+        }
+    };
+}
+function rule(create) {
+    return { meta: { type: 'problem' }, create };
+}
+const noComments = rule((context) => ({
+    Program() {
+        for (const comment of context.sourceCode.getAllComments()) {
+            if (comment.type === 'Shebang')
+                continue;
+            context.report({ loc: comment.loc, message: NO_COMMENTS_MESSAGE });
+        }
+    }
+}));
+const noPointerCursor = styleRule((declarations) => declarations
+    .filter((d) => d.property === 'cursor' && stringValue(d.value) === 'pointer')
+    .map((d) => ({ location: d.location, message: NO_POINTER_CURSOR_MESSAGE })));
+const useTokens = styleRule((declarations, context) => {
+    if (inFile(context, TOKENS_FILE) || inFile(context, APP_THEME_FILE))
+        return [];
+    return declarations.flatMap((d) => {
+        const raw = stringValue(d.value);
+        const isColorProperty = /color$/i.test(d.property) ||
+            d.property === 'fill' ||
+            d.property === 'stroke';
+        if ((isColorProperty &&
+            isRawLiteral(d.value) &&
+            !COLOR_KEYWORDS.has(raw ?? '')) ||
+            (raw !== undefined && RAW_COLOR.test(raw))) {
+            return [{ location: d.location, message: USE_COLOR_TOKEN_MESSAGE }];
+        }
+        if (FONT_PROPERTIES.has(d.property) &&
+            isRawLiteral(d.value) &&
+            raw !== 'inherit') {
+            return [{ location: d.location, message: USE_FONT_TOKEN_MESSAGE }];
+        }
+        return [];
+    });
+});
+const noInteractiveTransition = styleRule((declarations) => {
+    const interactiveStyles = new Set(declarations
+        .filter((d) => d.conditions.some((condition) => INTERACTIVE_CONDITIONS.has(condition)))
+        .map((d) => d.styleName));
+    return declarations
+        .filter((d) => interactiveStyles.has(d.styleName) &&
+        /^(transition|animation)(Duration|TimingFunction)$/.test(d.property) &&
+        !(d.value.type === 'MemberExpression' &&
+            child(d.value, 'object')?.['name'] === 'motion'))
+        .map((d) => ({
+        location: d.location,
+        message: NO_INTERACTIVE_TRANSITION_MESSAGE
+    }));
+});
+const hoverUsesHighlight = styleRule((declarations) => declarations
+    .filter((d) => (d.property === 'backgroundColor' || d.property === 'background') &&
+    (d.conditions.some((condition) => INTERACTIVE_CONDITIONS.has(condition)) ||
+        (SELECTED_STYLE_NAME.test(d.styleName) &&
+            d.conditions.length === 0)) &&
+    !isMember(d.value, 'colors', 'transparentHover') &&
+    !(!SELECTED_STYLE_NAME.test(d.styleName) && isButtonStateToken(d.value)) &&
+    !(d.value.type === 'Literal' && d.value['value'] === null))
+    .map((d) => ({
+    location: d.location,
+    message: HOVER_USES_HIGHLIGHT_MESSAGE
+})));
+const scrollViewOnly = styleRule((declarations, context) => {
+    if (inFile(context, SCROLL_AREA_FILE))
+        return [];
+    return declarations
+        .filter((d) => SCROLLING_OVERFLOW_PROPERTIES.has(d.property) &&
+        ['auto', 'scroll'].includes(stringValue(d.value) ?? ''))
+        .map((d) => ({ location: d.location, message: SCROLL_VIEW_ONLY_MESSAGE }));
+});
+const selectableOnly = styleRule((declarations, context) => {
+    if (inFile(context, SELECTABLE_FILE))
+        return [];
+    return declarations
+        .filter((d) => /^(Webkit)?[uU]serSelect$/.test(d.property))
+        .map((d) => ({ location: d.location, message: SELECTABLE_ONLY_MESSAGE }));
+});
+const useBreakpoints = rule((context) => ({
+    Literal(node) {
+        if (inFile(context, TOKENS_FILE) || !context.filename.includes('/src/')) {
+            return;
+        }
+        const value = stringValue(node);
+        if (value?.trimStart().startsWith('@media') === true &&
+            !value.includes('prefers-color-scheme')) {
+            context.report({ loc: node.loc, message: USE_BREAKPOINTS_MESSAGE });
+        }
+    }
+}));
+const darkModeInTokens = rule((context) => ({
+    Literal(node) {
+        if (inFile(context, TOKENS_FILE) || !context.filename.includes('/src/')) {
+            return;
+        }
+        if (stringValue(node)?.includes('prefers-color-scheme')) {
+            context.report({ loc: node.loc, message: DARK_MODE_IN_TOKENS_MESSAGE });
+        }
+    }
+}));
+function returnedValues(body) {
+    if (body.type !== 'BlockStatement')
+        return [body];
+    const found = [];
+    const visit = (node) => {
+        if (/Function/.test(node.type))
+            return;
+        if (node.type === 'ReturnStatement') {
+            const argument = child(node, 'argument');
+            if (argument !== undefined)
+                found.push(argument);
+            return;
+        }
+        for (const [key, value] of Object.entries(node)) {
+            if (key === 'parent')
+                continue;
+            if (Array.isArray(value))
+                value.filter(isNode).forEach(visit);
+            else if (isNode(value))
+                visit(value);
+        }
+    };
+    children(body, 'body').forEach(visit);
+    return found;
+}
+function possibleClassNameValues(node) {
+    switch (node.type) {
+        case 'JSXExpressionContainer':
+        case 'ParenthesizedExpression':
+        case 'TSAsExpression':
+        case 'TSNonNullExpression':
+            return possibleValuesOf(node, 'expression');
+        case 'ConditionalExpression':
+            return [
+                ...possibleValuesOf(node, 'consequent'),
+                ...possibleValuesOf(node, 'alternate')
+            ];
+        case 'LogicalExpression':
+            return node['operator'] === '&&'
+                ? possibleValuesOf(node, 'right')
+                : [
+                    ...possibleValuesOf(node, 'left'),
+                    ...possibleValuesOf(node, 'right')
+                ];
+        case 'BinaryExpression':
+            return node['operator'] === '+'
+                ? [
+                    ...possibleValuesOf(node, 'left'),
+                    ...possibleValuesOf(node, 'right')
+                ]
+                : [];
+        case 'ArrowFunctionExpression':
+        case 'FunctionExpression': {
+            const body = child(node, 'body');
+            return body === undefined
+                ? []
+                : returnedValues(body).flatMap(possibleClassNameValues);
+        }
+        default:
+            return [node];
+    }
+}
+function possibleValuesOf(node, key) {
+    const inner = child(node, key);
+    return inner === undefined ? [] : possibleClassNameValues(inner);
+}
+const noClassNameStrings = rule((context) => ({
+    JSXAttribute(node) {
+        const name = child(node, 'name');
+        const value = child(node, 'value');
+        if (name?.['name'] !== 'className' || value === undefined)
+            return;
+        for (const candidate of possibleClassNameValues(value)) {
+            const literal = stringValue(candidate);
+            if (candidate.type === 'TemplateLiteral' ||
+                (literal !== undefined && literal !== '')) {
+                context.report({
+                    loc: candidate.loc,
+                    message: NO_CLASSNAME_STRINGS_MESSAGE
+                });
+            }
+        }
+    }
+}));
+function isTypedStyleXStyles(type, program) {
+    if (type?.type !== 'TSTypeReference')
+        return false;
+    const typeName = child(type, 'typeName');
+    const name = typeName?.['name'];
+    if (name === 'Placement')
+        return true;
+    if (name === 'StyleXStyles') {
+        const args = child(type, 'typeArguments') ?? child(type, 'typeParameters');
+        const [first] = args === undefined ? [] : children(args, 'params');
+        return (first?.type === 'TSTypeLiteral' ||
+            first?.type === 'TSIntersectionType' ||
+            first?.type === 'TSTypeReference');
+    }
+    let aliased;
+    walk(program, (node) => {
+        if (node.type === 'TSTypeAliasDeclaration' &&
+            child(node, 'id')?.['name'] === name) {
+            aliased = child(node, 'typeAnnotation');
+        }
+    });
+    return aliased !== undefined && isTypedStyleXStyles(aliased, program);
+}
+const typedStyleProp = rule((context) => {
+    let program;
+    return {
+        Program(node) {
+            program = node;
+        },
+        TSPropertySignature(node) {
+            if (keyName(node) !== 'style' || program === undefined)
+                return;
+            const annotation = child(node, 'typeAnnotation');
+            const type = annotation === undefined
+                ? undefined
+                : child(annotation, 'typeAnnotation');
+            if (!isTypedStyleXStyles(type, program)) {
+                context.report({ loc: node.loc, message: TYPED_STYLE_PROP_MESSAGE });
+            }
+        }
+    };
+});
+const componentFileName = rule((context) => ({
+    Program(node) {
+        const expected = COMPONENT_FILE.exec(context.filename)?.[2];
+        if (expected === undefined)
+            return;
+        const exportedFunctions = children(node, 'body')
+            .filter((statement) => statement.type === 'ExportNamedDeclaration')
+            .map((statement) => child(statement, 'declaration'))
+            .filter((declaration) => declaration?.type === 'FunctionDeclaration')
+            .map((declaration) => declaration === undefined
+            ? undefined
+            : child(declaration, 'id')?.['name']);
+        if (!exportedFunctions.includes(expected)) {
+            context.report({ loc: node.loc, message: COMPONENT_FILE_NAME_MESSAGE });
+        }
+    }
+}));
+const HELPER_DECLARATIONS = new Set([
+    'VariableDeclaration',
+    'FunctionDeclaration'
+]);
+function isComponentExport(statement) {
+    return (statement.type === 'ExportNamedDeclaration' &&
+        child(statement, 'declaration')?.type === 'FunctionDeclaration');
+}
+const componentFirst = rule((context) => ({
+    Program(node) {
+        if (!COMPONENT_FILE.test(context.filename))
+            return;
+        for (const statement of children(node, 'body')) {
+            if (isComponentExport(statement))
+                return;
+            if (HELPER_DECLARATIONS.has(statement.type)) {
+                context.report({ loc: statement.loc, message: COMPONENT_FIRST_MESSAGE });
+            }
+        }
+    }
+}));
+const routesUnderAppLayout = rule((context) => ({
+    VariableDeclarator(node) {
+        if (!inFile(context, ROUTES_FILE))
+            return;
+        if (child(node, 'id')?.['name'] !== 'routes')
+            return;
+        const declared = child(node, 'init');
+        const routes = declared?.type === 'CallExpression'
+            ? children(declared, 'arguments')[0]
+            : declared;
+        const topLevel = routes?.type === 'ArrayExpression' ? children(routes, 'elements') : [];
+        const allUnderAppLayout = topLevel.length > 0 &&
+            topLevel.every((route) => children(route, 'properties').some((property) => keyName(property) === 'Component' &&
+                child(property, 'value')?.['name'] === 'AppLayout'));
+        if (!allUnderAppLayout) {
+            context.report({
+                loc: node.loc,
+                message: ROUTES_UNDER_APP_LAYOUT_MESSAGE
+            });
+        }
+    }
+}));
+const noRouteDataApis = rule((context) => ({
+    Property(node) {
+        if (inFile(context, ROUTES_FILE) &&
+            ROUTE_DATA_KEYS.has(keyName(node) ?? '')) {
+            context.report({ loc: node.loc, message: NO_ROUTE_DATA_APIS_MESSAGE });
+        }
+    }
+}));
+const useLink = rule((context) => ({
+    JSXOpeningElement(node) {
+        if (child(node, 'name')?.['name'] !== 'a')
+            return;
+        for (const attribute of children(node, 'attributes')) {
+            const value = child(attribute, 'value');
+            if (child(attribute, 'name')?.['name'] === 'href' &&
+                value !== undefined &&
+                stringValue(value)?.startsWith('/') === true) {
+                context.report({ loc: attribute.loc, message: USE_LINK_MESSAGE });
+            }
+        }
+    }
+}));
+function isTypeOnlyImport(node) {
+    const specifiers = children(node, 'specifiers');
+    return (node['importKind'] === 'type' ||
+        (specifiers.length > 0 &&
+            specifiers.every((specifier) => specifier['importKind'] === 'type')));
+}
+const storesInApp = rule((context) => ({
+    ImportDeclaration(node) {
+        const source = stringValue(child(node, 'source') ?? node) ?? '';
+        if (STORE_IMPORT.test(source) &&
+            !MAY_IMPORT_STORES.test(context.filename) &&
+            !isTypeOnlyImport(node)) {
+            context.report({ loc: node.loc, message: STORES_IN_APP_MESSAGE });
+        }
+    }
+}));
+const UNSUBSCRIBED_READS = new Set(['state', 'models', 'stores', 'getSnapshot']);
+const SRC_FILE = /(^|\/)src\//;
+const VIEW_FILE = /(^|\/)src\/(components|screens|layouts)\/.*\.tsx$/;
+const MODEL_FILE = /(^|\/)src\/models\/[A-Z][A-Za-z]*\.ts$/;
+const MAY_USE_MODEL = /(^|\/)src\/(screens|layouts)\//;
+function isPublicModelMember(member) {
+    if (keyName(member) === 'actions')
+        return false;
+    if (member.type === 'MethodDefinition') {
+        return member['kind'] === 'get' || keyName(member) === 'onPageOpen';
+    }
+    if (member.type !== 'PropertyDefinition')
+        return false;
+    const value = child(member, 'value');
+    return (value?.type === 'CallExpression' &&
+        child(value, 'callee')?.['name'] === 'command');
+}
+const modelMembers = rule((context) => ({
+    ClassBody(node) {
+        if (!MODEL_FILE.test(context.filename))
+            return;
+        for (const member of children(node, 'body')) {
+            if (!CLASS_MEMBERS.has(member.type))
+                continue;
+            if (member['kind'] === 'constructor')
+                continue;
+            const access = member['accessibility'];
+            const isPrivateGetter = access === 'private' && member['kind'] === 'get';
+            const isUnexpectedPublic = access !== 'private' && !isPublicModelMember(member);
+            if (isPrivateGetter || isUnexpectedPublic) {
+                context.report({ loc: member.loc, message: MODEL_MEMBERS_MESSAGE });
+            }
+        }
+    }
+}));
+const IMPURE_CALLS = new Set([
+    'Date.now',
+    'Math.random',
+    'crypto.randomUUID',
+    'performance.now',
+    'fetch'
+]);
+const SKIPPED_KEYS = new Set(['parent', 'loc', 'range']);
+function memberPath(node) {
+    if (node?.type === 'ThisExpression')
+        return 'this';
+    if (node?.type === 'Identifier')
+        return String(node['name']);
+    if (node?.type !== 'MemberExpression' || node['computed'] === true) {
+        return undefined;
+    }
+    const object = memberPath(child(node, 'object'));
+    const property = child(node, 'property');
+    return object === undefined || property?.type !== 'Identifier'
+        ? undefined
+        : `${object}.${String(property['name'])}`;
+}
+function childNodes(node) {
+    return Object.entries(node).flatMap(([key, value]) => {
+        if (SKIPPED_KEYS.has(key))
+            return [];
+        if (isNode(value))
+            return [value];
+        return Array.isArray(value) ? value.filter(isNode) : [];
+    });
+}
+function impurityOfCall(callee) {
+    if (callee === 'this.set')
+        return 'calls this.set()';
+    if (callee.startsWith('this.app.'))
+        return `calls ${callee}()`;
+    if (/^this\.stores\.\w+\.\w+$/.test(callee)) {
+        return `calls ${callee}(), a store method`;
+    }
+    return IMPURE_CALLS.has(callee) ? `reads ${callee}()` : undefined;
+}
+function impuritiesIn(body, members, seen) {
+    if (body === undefined)
+        return [];
+    const found = [];
+    const visit = (node) => {
+        if (node.type === 'CallExpression') {
+            const callee = memberPath(child(node, 'callee')) ?? '';
+            const what = impurityOfCall(callee);
+            if (what !== undefined)
+                found.push({ node, what });
+            const helper = /^this\.\w+$/.test(callee)
+                ? members.helpers.get(callee.slice(5))
+                : undefined;
+            if (helper !== undefined && !seen.has(callee)) {
+                seen.add(callee);
+                found.push(...impuritiesIn(helper, members, seen));
+            }
+        }
+        if (node.type === 'NewExpression' &&
+            memberPath(child(node, 'callee')) === 'Date') {
+            found.push({ node, what: 'reads new Date()' });
+        }
+        if (node.type === 'AwaitExpression')
+            found.push({ node, what: 'awaits' });
+        if (node.type === 'AssignmentExpression' &&
+            (memberPath(child(node, 'left')) ?? '').startsWith('this.')) {
+            found.push({ node, what: 'assigns to this' });
+        }
+        const path = memberPath(node);
+        if (node.type === 'MemberExpression' &&
+            path !== undefined &&
+            /^this\.\w+$/.test(path) &&
+            members.fields.has(path.slice(5))) {
+            found.push({ node, what: `reads the private field ${path}` });
+        }
+        for (const next of childNodes(node))
+            visit(next);
+    };
+    visit(body);
+    return found;
+}
+function modelMembersOf(members) {
+    const helpers = new Map();
+    const fields = new Set();
+    for (const member of members) {
+        const name = keyName(member);
+        if (name === undefined || member['accessibility'] !== 'private')
+            continue;
+        const value = child(member, 'value');
+        const isFunction = value?.type === 'FunctionExpression' ||
+            value?.type === 'ArrowFunctionExpression';
+        if (isFunction && value !== undefined)
+            helpers.set(name, value);
+        else if (member.type === 'PropertyDefinition')
+            fields.add(name);
+    }
+    return { helpers, fields };
+}
+const pureGetters = rule((context) => ({
+    ClassBody(node) {
+        if (!MODEL_FILE.test(context.filename))
+            return;
+        const members = children(node, 'body');
+        const known = modelMembersOf(members);
+        for (const member of members) {
+            if (member.type !== 'MethodDefinition' || member['kind'] !== 'get') {
+                continue;
+            }
+            for (const { node: found, what } of impuritiesIn(child(member, 'value'), known, new Set())) {
+                context.report({
+                    loc: found.loc,
+                    message: `${PURE_GETTERS_MESSAGE} This one ${what}.`
+                });
+            }
+        }
+    }
+}));
+const ACTIONS_FOLDER = /(^|\/)src\/actions\//;
+const ACTIONS_FILE = /(^|\/)src\/actions\/[a-z][A-Za-z]*\.ts$/;
+const ACTION_BUILDERS = new Set(['action', 'defineActions']);
+const VALUES_ACTIONS_MAY_NOT_IMPORT = /\/src\/(models|stores|components)\//;
+const actionsWhere = rule((context) => ({
+    CallExpression(node) {
+        const callee = String(child(node, 'callee')?.['name'] ?? '');
+        if (!ACTION_BUILDERS.has(callee))
+            return;
+        if (ACTIONS_FOLDER.test(context.filename))
+            return;
+        context.report({ loc: node.loc, message: ACTIONS_WHERE_MESSAGE });
+    }
+}));
+const pureActions = rule((context) => {
+    if (!ACTIONS_FILE.test(context.filename))
+        return {};
+    const report = (node, what) => {
+        context.report({
+            loc: node.loc,
+            message: `${PURE_ACTIONS_MESSAGE} This one ${what}.`
+        });
+    };
+    return {
+        ImportDeclaration(node) {
+            const source = stringValue(child(node, 'source') ?? node) ?? '';
+            if (VALUES_ACTIONS_MAY_NOT_IMPORT.test(source) &&
+                !isTypeOnlyImport(node)) {
+                report(node, `imports a value from ${source}`);
+            }
+        },
+        CallExpression(node) {
+            const callee = memberPath(child(node, 'callee')) ?? '';
+            if (IMPURE_CALLS.has(callee))
+                report(node, `reads ${callee}()`);
+        },
+        NewExpression(node) {
+            if (memberPath(child(node, 'callee')) === 'Date') {
+                report(node, 'reads new Date()');
+            }
+        },
+        AwaitExpression(node) {
+            report(node, 'awaits');
+        },
+        ThisExpression(node) {
+            report(node, 'uses this');
+        }
+    };
+});
+const modelByName = rule((context) => {
+    const models = new Set();
+    return {
+        VariableDeclarator(node) {
+            const id = child(node, 'id');
+            const init = child(node, 'init');
+            const isUseModel = init?.type === 'CallExpression' &&
+                child(init, 'callee')?.['name'] === 'useModel';
+            if (isUseModel && id?.type === 'Identifier')
+                models.add(String(id['name']));
+            const readsModel = isUseModel ||
+                (init?.type === 'Identifier' && models.has(String(init['name'])));
+            if (readsModel && id?.type === 'ObjectPattern') {
+                context.report({ loc: node.loc, message: MODEL_BY_NAME_MESSAGE });
+            }
+        }
+    };
+});
+const useModelWhere = rule((context) => ({
+    CallExpression(node) {
+        if (child(node, 'callee')?.['name'] !== 'useModel')
+            return;
+        if (MAY_USE_MODEL.test(context.filename))
+            return;
+        context.report({ loc: node.loc, message: USE_MODEL_WHERE_MESSAGE });
+    }
+}));
+const stateViaHooks = rule((context) => ({
+    MemberExpression(node) {
+        if (!VIEW_FILE.test(context.filename))
+            return;
+        const property = child(node, 'property');
+        if (node['computed'] !== true &&
+            UNSUBSCRIBED_READS.has(String(property?.['name'] ?? ''))) {
+            context.report({ loc: node.loc, message: STATE_VIA_HOOKS_MESSAGE });
+        }
+    }
+}));
+function returnsObjectOfMethods(fn) {
+    const body = child(fn, 'body');
+    const returned = [];
+    if (body?.type === 'ObjectExpression')
+        returned.push(body);
+    if (body?.type === 'BlockStatement') {
+        for (const statement of children(body, 'body')) {
+            const argument = child(statement, 'argument');
+            if (statement.type === 'ReturnStatement' && argument !== undefined) {
+                returned.push(argument);
+            }
+        }
+    }
+    return returned.some((value) => value.type === 'ObjectExpression' &&
+        children(value, 'properties').some((property) => {
+            const propertyValue = child(property, 'value');
+            return (property['method'] === true ||
+                propertyValue?.type === 'ArrowFunctionExpression' ||
+                propertyValue?.type === 'FunctionExpression');
+        }));
+}
+const CLASS_MEMBERS = new Set([
+    'MethodDefinition',
+    'PropertyDefinition',
+    'AccessorProperty',
+    'TSAbstractMethodDefinition',
+    'TSAbstractPropertyDefinition'
+]);
+const explicitAccess = rule((context) => ({
+    ClassBody(node) {
+        for (const member of children(node, 'body')) {
+            if (!CLASS_MEMBERS.has(member.type))
+                continue;
+            if (member['kind'] === 'constructor')
+                continue;
+            const isHashPrivate = child(member, 'key')?.type === 'PrivateIdentifier';
+            if (isHashPrivate || typeof member['accessibility'] !== 'string') {
+                context.report({ loc: member.loc, message: EXPLICIT_ACCESS_MESSAGE });
+            }
+        }
+    }
+}));
+const classesNotFactories = rule((context) => {
+    const check = (node) => {
+        if (SRC_FILE.test(context.filename) && returnsObjectOfMethods(node)) {
+            context.report({ loc: node.loc, message: CLASSES_NOT_FACTORIES_MESSAGE });
+        }
+    };
+    return {
+        FunctionDeclaration: check,
+        FunctionExpression: check,
+        ArrowFunctionExpression: check
+    };
+});
+const devOnlySignIn = rule((context) => ({
+    MemberExpression(node) {
+        const object = child(node, 'object');
+        if (object?.type === 'MetaProperty' &&
+            child(node, 'property')?.['name'] === 'env' &&
+            SERVER_FILE.test(context.filename)) {
+            context.report({ loc: node.loc, message: DEV_ONLY_SIGN_IN_MESSAGE });
+        }
+    }
+}));
+function attributeNamed(element, name) {
+    return children(element, 'attributes').find((attribute) => child(attribute, 'name')?.['name'] === name);
+}
+function elementName(element) {
+    const name = child(element, 'name');
+    return name?.type === 'JSXIdentifier' ? String(name['name']) : undefined;
+}
+const usePrimitives = rule((context) => ({
+    JSXOpeningElement(node) {
+        if (!SRC_FILE.test(context.filename))
+            return;
+        if (PRIMITIVE_ELEMENTS.has(elementName(node) ?? '')) {
+            context.report({ loc: node.loc, message: USE_PRIMITIVES_MESSAGE });
+        }
+    }
+}));
+const noWidgetRoles = rule((context) => ({
+    JSXAttribute(node) {
+        if (!SRC_FILE.test(context.filename))
+            return;
+        if (child(node, 'name')?.['name'] !== 'role')
+            return;
+        const value = child(node, 'value');
+        const role = value === undefined ? undefined : stringValue(value);
+        if (role !== undefined && WIDGET_ROLES.has(role)) {
+            context.report({ loc: node.loc, message: NO_WIDGET_ROLES_MESSAGE });
+        }
+    }
+}));
+const noClickOnStatic = rule((context) => ({
+    JSXOpeningElement(node) {
+        if (!SRC_FILE.test(context.filename))
+            return;
+        if (!STATIC_ELEMENTS.has(elementName(node) ?? ''))
+            return;
+        if (attributeNamed(node, 'role') !== undefined)
+            return;
+        for (const handler of CLICK_HANDLERS) {
+            const attribute = attributeNamed(node, handler);
+            if (attribute !== undefined) {
+                context.report({
+                    loc: attribute.loc,
+                    message: NO_CLICK_ON_STATIC_MESSAGE
+                });
+            }
+        }
+    }
+}));
+const primitiveNames = rule((context) => ({
+    Program(node) {
+        if (!COMPONENT_FILE.test(context.filename))
+            return;
+        for (const statement of children(node, 'body')) {
+            if (statement.type !== 'ExportNamedDeclaration')
+                continue;
+            const declaration = child(statement, 'declaration');
+            const name = String(child(declaration ?? statement, 'id')?.['name'] ?? '');
+            if (PRIMITIVES.has(name)) {
+                context.report({
+                    loc: statement.loc,
+                    message: PRIMITIVE_NAMES_MESSAGE.replaceAll('{name}', name)
+                });
+            }
+        }
+    }
+}));
+function isTokenOf(groups, node) {
+    if (node.type === 'MemberExpression') {
+        return groups.has(String(child(node, 'object')?.['name'] ?? ''));
+    }
+    if (node.type === 'TemplateLiteral') {
+        const expressions = children(node, 'expressions');
+        return (expressions.length > 0 &&
+            expressions.every((expression) => isTokenOf(groups, expression)));
+    }
+    return false;
+}
+function isNeutralValue(node) {
+    if (node.type !== 'Literal')
+        return false;
+    const value = node['value'];
+    return (value === null || value === 0 || value === 'auto' || value === 'inherit');
+}
+function checksSizes(context) {
+    const [options] = context.options;
+    return (typeof options === 'object' &&
+        options !== null &&
+        Reflect.get(options, 'sizes') === true);
+}
+const SIZES_OPTION = {
+    type: 'problem',
+    schema: [
+        {
+            type: 'object',
+            properties: { sizes: { type: 'boolean' } },
+            additionalProperties: false
+        }
+    ]
+};
+const checkSpacing = styleRule((declarations, context) => {
+    if (!SRC_FILE.test(context.filename))
+        return [];
+    const sizes = checksSizes(context);
+    return declarations.flatMap((d) => {
+        if (SPACING_PROPERTY.test(d.property)) {
+            if (isNeutralValue(d.value) || isTokenOf(SPACING_TOKEN_GROUPS, d.value)) {
+                return [];
+            }
+            return [{ location: d.location, message: USE_SPACE_TOKENS_MESSAGE }];
+        }
+        if (sizes && SIZE_PROPERTIES.has(d.property)) {
+            const raw = stringValue(d.value);
+            if (isNeutralValue(d.value) ||
+                isTokenOf(SIZE_TOKEN_GROUPS, d.value) ||
+                (raw !== undefined && SIZE_KEYWORDS.test(raw))) {
+                return [];
+            }
+            return [{ location: d.location, message: USE_SIZE_TOKENS_MESSAGE }];
+        }
+        return [];
+    });
+});
+function isDomElement(element) {
+    const name = element === undefined ? undefined : child(element, 'openingElement');
+    const tag = name === undefined ? undefined : elementName(name);
+    return tag !== undefined && /^[a-z]/.test(tag);
+}
+function isLooseText(node) {
+    if (node.type === 'JSXText')
+        return String(node['value']).trim() !== '';
+    if (node.type !== 'JSXExpressionContainer')
+        return false;
+    const expression = child(node, 'expression');
+    return (expression !== undefined &&
+        (stringValue(expression) !== undefined ||
+            expression.type === 'TemplateLiteral'));
+}
+const textViaText = rule((context) => {
+    if (!SRC_FILE.test(context.filename))
+        return {};
+    return {
+        CallExpression(node) {
+            if (!isStylexCreate(node))
+                return;
+            for (const d of styleDeclarations(node)) {
+                if (TEXT_PROPERTIES.has(d.property)) {
+                    context.report({ loc: d.location, message: TEXT_VIA_TEXT_MESSAGE });
+                }
+            }
+        },
+        JSXOpeningElement(node) {
+            if (TEXT_ELEMENTS.has(elementName(node) ?? '')) {
+                context.report({ loc: node.loc, message: TEXT_ELEMENTS_MESSAGE });
+            }
+        },
+        JSXElement(node) {
+            if (!isDomElement(node))
+                return;
+            for (const inner of children(node, 'children')) {
+                if (isLooseText(inner)) {
+                    context.report({ loc: inner.loc, message: LOOSE_TEXT_MESSAGE });
+                }
+            }
+        }
+    };
+});
+const composeInScreens = rule((context) => {
+    if (!SCREEN_FILE.test(context.filename))
+        return {};
+    return {
+        ImportDeclaration(node) {
+            const source = stringValue(child(node, 'source') ?? node) ?? '';
+            if (STYLE_SOURCES.has(source)) {
+                context.report({ loc: node.loc, message: COMPOSE_IN_SCREENS_MESSAGE });
+            }
+        },
+        JSXOpeningElement(node) {
+            if (/^[a-z]/.test(elementName(node) ?? '')) {
+                context.report({ loc: node.loc, message: COMPOSE_IN_SCREENS_MESSAGE });
+            }
+        }
+    };
+});
+const noHoverInApp = styleRule((declarations, context) => {
+    if (!SRC_FILE.test(context.filename))
+        return [];
+    return declarations
+        .filter((d) => d.conditions.some((condition) => POINTER_CONDITIONS.has(condition)))
+        .map((d) => ({ location: d.location, message: NO_HOVER_IN_APP_MESSAGE }));
+});
+export default {
+    meta: { name: 'pattern' },
+    rules: {
+        'no-comments': noComments,
+        'no-pointer-cursor': noPointerCursor,
+        'use-tokens': useTokens,
+        'no-interactive-transition': noInteractiveTransition,
+        'hover-uses-highlight': hoverUsesHighlight,
+        'scroll-view-only': scrollViewOnly,
+        'selectable-only': selectableOnly,
+        'dark-mode-in-tokens': darkModeInTokens,
+        'use-breakpoints': useBreakpoints,
+        'no-classname-strings': noClassNameStrings,
+        'typed-style-prop': typedStyleProp,
+        'component-file-name': componentFileName,
+        'component-first': componentFirst,
+        'routes-under-app-layout': routesUnderAppLayout,
+        'no-route-data-apis': noRouteDataApis,
+        'use-link': useLink,
+        'stores-in-app': storesInApp,
+        'state-via-hooks': stateViaHooks,
+        'model-members': modelMembers,
+        'pure-getters': pureGetters,
+        'actions-where': actionsWhere,
+        'pure-actions': pureActions,
+        'use-model-where': useModelWhere,
+        'model-by-name': modelByName,
+        'classes-not-factories': classesNotFactories,
+        'explicit-access': explicitAccess,
+        'dev-only-sign-in': devOnlySignIn,
+        'use-primitives': usePrimitives,
+        'no-widget-roles': noWidgetRoles,
+        'no-click-on-static': noClickOnStatic,
+        'primitive-names': primitiveNames,
+        'use-space-tokens': { ...checkSpacing, meta: SIZES_OPTION },
+        'text-via-text': textViaText,
+        'compose-in-screens': composeInScreens,
+        'no-hover-in-app': noHoverInApp
+    }
+};