@gallop.software/canon 1.0.0 → 2.0.1

package/dist/eslint/index.d.ts

@@ -0,0 +1,37 @@
+declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'no-client-blocks': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noClientBlocks", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        'no-container-in-section': import("@typescript-eslint/utils/ts-eslint").RuleModule<"noContainerInSection", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        'prefer-component-props': import("@typescript-eslint/utils/ts-eslint").RuleModule<"preferComponentProps", [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener> & {
+            name: string;
+        };
+        'prefer-typography-components': import("eslint").Rule.RuleModule;
+    };
+    configs: {
+        speedwell: {
+            plugins: string[];
+            rules: {
+                'gallop/no-client-blocks': string;
+                'gallop/no-container-in-section': string;
+                'gallop/prefer-component-props': string;
+            };
+        };
+        recommended: {
+            plugins: string[];
+            rules: {
+                'gallop/no-client-blocks': string;
+                'gallop/no-container-in-section': string;
+                'gallop/prefer-component-props': string;
+            };
+        };
+    };
+};
+export default plugin;

package/dist/eslint/index.js

@@ -0,0 +1,24 @@
+import noClientBlocks from './rules/no-client-blocks.js';
+import noContainerInSection from './rules/no-container-in-section.js';
+import preferComponentProps from './rules/prefer-component-props.js';
+import preferTypographyComponents from './rules/prefer-typography-components.js';
+import speedwellConfig from './configs/speedwell.js';
+import recommendedConfig from './configs/recommended.js';
+const plugin = {
+    meta: {
+        name: 'eslint-plugin-gallop',
+        version: '1.0.1',
+    },
+    rules: {
+        'no-client-blocks': noClientBlocks,
+        'no-container-in-section': noContainerInSection,
+        'prefer-component-props': preferComponentProps,
+        'prefer-typography-components': preferTypographyComponents,
+    },
+    configs: {
+        speedwell: speedwellConfig,
+        recommended: recommendedConfig,
+    },
+};
+export default plugin;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZXNsaW50L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sY0FBYyxNQUFNLDZCQUE2QixDQUFBO0FBQ3hELE9BQU8sb0JBQW9CLE1BQU0sb0NBQW9DLENBQUE7QUFDckUsT0FBTyxvQkFBb0IsTUFBTSxtQ0FBbUMsQ0FBQTtBQUNwRSxPQUFPLDBCQUEwQixNQUFNLHlDQUF5QyxDQUFBO0FBQ2hGLE9BQU8sZUFBZSxNQUFNLHdCQUF3QixDQUFBO0FBQ3BELE9BQU8saUJBQWlCLE1BQU0sMEJBQTBCLENBQUE7QUFFeEQsTUFBTSxNQUFNLEdBQUc7SUFDYixJQUFJLEVBQUU7UUFDSixJQUFJLEVBQUUsc0JBQXNCO1FBQzVCLE9BQU8sRUFBRSxPQUFPO0tBQ2pCO0lBQ0QsS0FBSyxFQUFFO1FBQ0wsa0JBQWtCLEVBQUUsY0FBYztRQUNsQyx5QkFBeUIsRUFBRSxvQkFBb0I7UUFDL0Msd0JBQXdCLEVBQUUsb0JBQW9CO1FBQzlDLDhCQUE4QixFQUFFLDBCQUEwQjtLQUMzRDtJQUNELE9BQU8sRUFBRTtRQUNQLFNBQVMsRUFBRSxlQUFlO1FBQzFCLFdBQVcsRUFBRSxpQkFBaUI7S0FDL0I7Q0FDRixDQUFBO0FBRUQsZUFBZSxNQUFNLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgbm9DbGllbnRCbG9ja3MgZnJvbSAnLi9ydWxlcy9uby1jbGllbnQtYmxvY2tzLmpzJ1xuaW1wb3J0IG5vQ29udGFpbmVySW5TZWN0aW9uIGZyb20gJy4vcnVsZXMvbm8tY29udGFpbmVyLWluLXNlY3Rpb24uanMnXG5pbXBvcnQgcHJlZmVyQ29tcG9uZW50UHJvcHMgZnJvbSAnLi9ydWxlcy9wcmVmZXItY29tcG9uZW50LXByb3BzLmpzJ1xuaW1wb3J0IHByZWZlclR5cG9ncmFwaHlDb21wb25lbnRzIGZyb20gJy4vcnVsZXMvcHJlZmVyLXR5cG9ncmFwaHktY29tcG9uZW50cy5qcydcbmltcG9ydCBzcGVlZHdlbGxDb25maWcgZnJvbSAnLi9jb25maWdzL3NwZWVkd2VsbC5qcydcbmltcG9ydCByZWNvbW1lbmRlZENvbmZpZyBmcm9tICcuL2NvbmZpZ3MvcmVjb21tZW5kZWQuanMnXG5cbmNvbnN0IHBsdWdpbiA9IHtcbiAgbWV0YToge1xuICAgIG5hbWU6ICdlc2xpbnQtcGx1Z2luLWdhbGxvcCcsXG4gICAgdmVyc2lvbjogJzEuMC4xJyxcbiAgfSxcbiAgcnVsZXM6IHtcbiAgICAnbm8tY2xpZW50LWJsb2Nrcyc6IG5vQ2xpZW50QmxvY2tzLFxuICAgICduby1jb250YWluZXItaW4tc2VjdGlvbic6IG5vQ29udGFpbmVySW5TZWN0aW9uLFxuICAgICdwcmVmZXItY29tcG9uZW50LXByb3BzJzogcHJlZmVyQ29tcG9uZW50UHJvcHMsXG4gICAgJ3ByZWZlci10eXBvZ3JhcGh5LWNvbXBvbmVudHMnOiBwcmVmZXJUeXBvZ3JhcGh5Q29tcG9uZW50cyxcbiAgfSxcbiAgY29uZmlnczoge1xuICAgIHNwZWVkd2VsbDogc3BlZWR3ZWxsQ29uZmlnLFxuICAgIHJlY29tbWVuZGVkOiByZWNvbW1lbmRlZENvbmZpZyxcbiAgfSxcbn1cblxuZXhwb3J0IGRlZmF1bHQgcGx1Z2luXG4iXX0=

package/dist/eslint/rules/no-client-blocks.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"noClientBlocks", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/eslint/rules/no-client-blocks.js

@@ -0,0 +1,45 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getCanonUrl, getCanonPattern } from '../utils/canon.js';
+const RULE_NAME = 'no-client-blocks';
+const pattern = getCanonPattern(RULE_NAME);
+const createRule = ESLintUtils.RuleCreator(() => getCanonUrl(RULE_NAME));
+export default createRule({
+    name: RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: pattern?.summary || 'Blocks must be server components',
+        },
+        messages: {
+            noClientBlocks: `[Canon ${pattern?.id || '001'}] Block "{{blockName}}" uses 'use client'. Extract hooks and client-side logic into a component in src/components/, then import it here. See: ${pattern?.title || 'Server-First Blocks'} pattern.`,
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const filename = context.filename || context.getFilename();
+        // Only check files in src/blocks/
+        if (!filename.includes('/blocks/') && !filename.includes('\\blocks\\')) {
+            return {};
+        }
+        return {
+            // Check for 'use client' directive at the top of the file
+            ExpressionStatement(node) {
+                if (node.expression.type === 'Literal' &&
+                    node.expression.value === 'use client') {
+                    // Extract block name from filename
+                    const match = filename.match(/([^/\\]+)\.tsx?$/);
+                    const blockName = match ? match[1] : 'unknown';
+                    context.report({
+                        node,
+                        messageId: 'noClientBlocks',
+                        data: {
+                            blockName,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/eslint/rules/no-container-in-section.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"noContainerInSection", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/eslint/rules/no-container-in-section.js

@@ -0,0 +1,50 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getCanonUrl, getCanonPattern } from '../utils/canon.js';
+const RULE_NAME = 'no-container-in-section';
+const pattern = getCanonPattern(RULE_NAME);
+const createRule = ESLintUtils.RuleCreator(() => getCanonUrl(RULE_NAME));
+export default createRule({
+    name: RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: pattern?.summary || 'No Container inside Section',
+        },
+        messages: {
+            noContainerInSection: `[Canon ${pattern?.id || '002'}] Container inside Section is redundant. Section already provides max-width containment. Use Section's innerAlign prop or a plain div instead.`,
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track if we're inside a Section component
+        let sectionDepth = 0;
+        function isJSXElementNamed(node, name) {
+            return (node.name.type === 'JSXIdentifier' &&
+                node.name.name === name);
+        }
+        return {
+            JSXOpeningElement(node) {
+                // Check if entering a Section
+                if (isJSXElementNamed(node, 'Section')) {
+                    sectionDepth++;
+                }
+                // Check if we're inside a Section and found a Container
+                if (sectionDepth > 0 && isJSXElementNamed(node, 'Container')) {
+                    context.report({
+                        node,
+                        messageId: 'noContainerInSection',
+                    });
+                }
+            },
+            JSXClosingElement(node) {
+                // Check if leaving a Section
+                if (node.name.type === 'JSXIdentifier' &&
+                    node.name.name === 'Section') {
+                    sectionDepth--;
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/eslint/rules/prefer-component-props.d.ts

@@ -0,0 +1,5 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+declare const _default: ESLintUtils.RuleModule<"preferComponentProps", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};
+export default _default;

package/dist/eslint/rules/prefer-component-props.js

@@ -0,0 +1,100 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+import { getCanonUrl, getCanonPattern } from '../utils/canon.js';
+const RULE_NAME = 'prefer-component-props';
+const pattern = getCanonPattern(RULE_NAME);
+const createRule = ESLintUtils.RuleCreator(() => getCanonUrl(RULE_NAME));
+// Map of component names to their style props and corresponding Tailwind patterns
+const componentPropMappings = {
+    Paragraph: {
+        margin: /^m([by])?-/, // m- (all), mb- (bottom), my- (y-axis) - all affect bottom margin
+        color: /^text-(body|contrast|accent|white|black)/,
+        fontSize: /^text-(xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl)$/,
+        lineHeight: /^leading-/,
+        textAlign: /^text-(left|center|right|justify)$/,
+        fontWeight: /^font-(thin|extralight|light|normal|medium|semibold|bold|extrabold|black)$/,
+    },
+    Heading: {
+        margin: /^m([by])?-/, // m- (all), mb- (bottom), my- (y-axis) - all affect bottom margin
+        color: /^text-(body|contrast|accent|white|black)/,
+        fontSize: /^text-(xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl)$/,
+        lineHeight: /^leading-/,
+        textAlign: /^text-(left|center|right|justify)$/,
+        fontWeight: /^font-(thin|extralight|light|normal|medium|semibold|bold|extrabold|black)$/,
+    },
+    Accent: {
+        margin: /^m([by])?-/, // m- (all), mb- (bottom), my- (y-axis) - all affect bottom margin
+        color: /^text-(body|contrast|accent|white|black)/,
+        size: /^text-(xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl)$/,
+        textAlign: /^text-(left|center|right|justify)$/,
+    },
+    Button: {
+        margin: /^m([by])?-/, // m- (all), mb- (bottom), my- (y-axis) - all affect bottom margin
+    },
+    Label: {
+        margin: /^m([by])?-/, // m- (all), mb- (bottom), my- (y-axis) - all affect bottom margin
+        color: /^text-(body|contrast|accent|white|black)/,
+    },
+};
+export default createRule({
+    name: RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: pattern?.summary || 'Use props over className for supported styles',
+        },
+        messages: {
+            preferComponentProps: `[Canon ${pattern?.id || '004'}] "{{className}}" in className should use the "{{propName}}" prop instead. Replace className="{{className}}" with {{propName}}="{{className}}".`,
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            JSXOpeningElement(node) {
+                // Get the component name
+                if (node.name.type !== 'JSXIdentifier')
+                    return;
+                const componentName = node.name.name;
+                // Check if this component has prop mappings
+                const propMappings = componentPropMappings[componentName];
+                if (!propMappings)
+                    return;
+                // Find the className attribute
+                const classNameAttr = node.attributes.find((attr) => attr.type === 'JSXAttribute' &&
+                    attr.name.type === 'JSXIdentifier' &&
+                    attr.name.name === 'className');
+                if (!classNameAttr || !classNameAttr.value)
+                    return;
+                // Extract class string value
+                let classValue = null;
+                if (classNameAttr.value.type === 'Literal') {
+                    classValue = String(classNameAttr.value.value);
+                }
+                else if (classNameAttr.value.type === 'JSXExpressionContainer' &&
+                    classNameAttr.value.expression.type === 'Literal') {
+                    classValue = String(classNameAttr.value.expression.value);
+                }
+                if (!classValue)
+                    return;
+                // Split into individual classes and check each
+                const classes = classValue.split(/\s+/).filter(Boolean);
+                for (const cls of classes) {
+                    for (const [propName, pattern] of Object.entries(propMappings)) {
+                        if (pattern.test(cls)) {
+                            context.report({
+                                node: classNameAttr,
+                                messageId: 'preferComponentProps',
+                                data: {
+                                    className: cls,
+                                    propName,
+                                },
+                            });
+                            break; // Only report once per class
+                        }
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prefer-component-props.js","sourceRoot":"","sources":["../../../src/eslint/rules/prefer-component-props.ts"],"names":[],"mappings":"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","sourcesContent":["import { ESLintUtils, TSESTree } from '@typescript-eslint/utils'\nimport { getCanonUrl, getCanonPattern } from '../utils/canon.js'\n\nconst RULE_NAME = 'prefer-component-props'\nconst pattern = getCanonPattern(RULE_NAME)\n\nconst createRule = ESLintUtils.RuleCreator(() => getCanonUrl(RULE_NAME))\n\ntype MessageIds = 'preferComponentProps'\n\n// Map of component names to their style props and corresponding Tailwind patterns\nconst componentPropMappings: Record<string, Record<string, RegExp>> = {\n  Paragraph: {\n    margin: /^m([by])?-/, // m- (all), mb- (bottom), my- (y-axis) - all affect bottom margin\n    color: /^text-(body|contrast|accent|white|black)/,\n    fontSize: /^text-(xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl)$/,\n    lineHeight: /^leading-/,\n    textAlign: /^text-(left|center|right|justify)$/,\n    fontWeight: /^font-(thin|extralight|light|normal|medium|semibold|bold|extrabold|black)$/,\n  },\n  Heading: {\n    margin: /^m([by])?-/, // m- (all), mb- (bottom), my- (y-axis) - all affect bottom margin\n    color: /^text-(body|contrast|accent|white|black)/,\n    fontSize: /^text-(xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl)$/,\n    lineHeight: /^leading-/,\n    textAlign: /^text-(left|center|right|justify)$/,\n    fontWeight: /^font-(thin|extralight|light|normal|medium|semibold|bold|extrabold|black)$/,\n  },\n  Accent: {\n    margin: /^m([by])?-/, // m- (all), mb- (bottom), my- (y-axis) - all affect bottom margin\n    color: /^text-(body|contrast|accent|white|black)/,\n    size: /^text-(xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl)$/,\n    textAlign: /^text-(left|center|right|justify)$/,\n  },\n  Button: {\n    margin: /^m([by])?-/, // m- (all), mb- (bottom), my- (y-axis) - all affect bottom margin\n  },\n  Label: {\n    margin: /^m([by])?-/, // m- (all), mb- (bottom), my- (y-axis) - all affect bottom margin\n    color: /^text-(body|contrast|accent|white|black)/,\n  },\n}\n\nexport default createRule<[], MessageIds>({\n  name: RULE_NAME,\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description: pattern?.summary || 'Use props over className for supported styles',\n    },\n    messages: {\n      preferComponentProps: `[Canon ${pattern?.id || '004'}] \"{{className}}\" in className should use the \"{{propName}}\" prop instead. Replace className=\"{{className}}\" with {{propName}}=\"{{className}}\".`,\n    },\n    schema: [],\n  },\n  defaultOptions: [],\n  create(context) {\n    return {\n      JSXOpeningElement(node) {\n        // Get the component name\n        if (node.name.type !== 'JSXIdentifier') return\n        const componentName = node.name.name\n\n        // Check if this component has prop mappings\n        const propMappings = componentPropMappings[componentName]\n        if (!propMappings) return\n\n        // Find the className attribute\n        const classNameAttr = node.attributes.find(\n          (attr): attr is TSESTree.JSXAttribute =>\n            attr.type === 'JSXAttribute' &&\n            attr.name.type === 'JSXIdentifier' &&\n            attr.name.name === 'className'\n        )\n\n        if (!classNameAttr || !classNameAttr.value) return\n\n        // Extract class string value\n        let classValue: string | null = null\n\n        if (classNameAttr.value.type === 'Literal') {\n          classValue = String(classNameAttr.value.value)\n        } else if (\n          classNameAttr.value.type === 'JSXExpressionContainer' &&\n          classNameAttr.value.expression.type === 'Literal'\n        ) {\n          classValue = String(classNameAttr.value.expression.value)\n        }\n\n        if (!classValue) return\n\n        // Split into individual classes and check each\n        const classes = classValue.split(/\\s+/).filter(Boolean)\n\n        for (const cls of classes) {\n          for (const [propName, pattern] of Object.entries(propMappings)) {\n            if (pattern.test(cls)) {\n              context.report({\n                node: classNameAttr,\n                messageId: 'preferComponentProps',\n                data: {\n                  className: cls,\n                  propName,\n                },\n              })\n              break // Only report once per class\n            }\n          }\n        }\n      },\n    }\n  },\n})\n"]}

package/dist/eslint/rules/prefer-typography-components.d.ts

@@ -0,0 +1,3 @@
+import type { Rule } from 'eslint';
+declare const rule: Rule.RuleModule;
+export default rule;

package/dist/eslint/rules/prefer-typography-components.js

@@ -0,0 +1,76 @@
+import { getCanonUrl, getCanonPattern } from '../utils/canon.js';
+const RULE_NAME = 'prefer-typography-components';
+const pattern = getCanonPattern(RULE_NAME);
+const rule = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: pattern?.summary || 'Use Paragraph/Span, not raw tags',
+            recommended: true,
+            url: getCanonUrl(RULE_NAME),
+        },
+        messages: {
+            useParagraph: `[Canon ${pattern?.id || '003'}] Use the Paragraph component instead of <p>. Import: import { Paragraph } from "@/components"`,
+            useSpan: `[Canon ${pattern?.id || '003'}] Use the Span component instead of <span> for text content. Import: import { Span } from "@/components"`,
+        },
+        schema: [],
+    },
+    create(context) {
+        const filename = context.filename || context.getFilename();
+        // Only apply to block files
+        if (!filename.includes('/blocks/')) {
+            return {};
+        }
+        return {
+            JSXOpeningElement(node) {
+                const elementName = node.name?.name;
+                if (elementName === 'p') {
+                    context.report({
+                        node,
+                        messageId: 'useParagraph',
+                    });
+                }
+                if (elementName === 'span') {
+                    // Skip spans that are inside typography components (Heading, Paragraph, Label, etc.)
+                    // These are used for inline styling effects like gradient text, emphasis, etc.
+                    const typographyComponents = ['Heading', 'Paragraph', 'Label', 'Span', 'Quote', 'Subheading', 'Accent'];
+                    let parent = node.parent;
+                    while (parent) {
+                        if (parent.type === 'JSXElement' &&
+                            parent.openingElement?.name?.name &&
+                            typographyComponents.includes(parent.openingElement.name.name)) {
+                            // Span is inside a typography component, skip warning
+                            return;
+                        }
+                        parent = parent.parent;
+                    }
+                    // Check className for text-related classes and gradient text
+                    let hasTextClasses = false;
+                    let isGradientText = false;
+                    node.attributes?.forEach((attr) => {
+                        if (attr.type === 'JSXAttribute' && attr.name?.name === 'className') {
+                            const value = attr.value?.value || '';
+                            // Check for text-related Tailwind classes
+                            if (/\b(text-|font-|leading-|tracking-)/.test(value)) {
+                                hasTextClasses = true;
+                            }
+                            // Skip gradient text spans (bg-clip-text is used for gradient text effects)
+                            if (/\bbg-clip-text\b/.test(value)) {
+                                isGradientText = true;
+                            }
+                        }
+                    });
+                    // Only warn if the span has text styling and is not gradient text
+                    if (hasTextClasses && !isGradientText) {
+                        context.report({
+                            node,
+                            messageId: 'useSpan',
+                        });
+                    }
+                }
+            },
+        };
+    },
+};
+export default rule;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/eslint/utils/canon.d.ts

@@ -0,0 +1,25 @@
+import { type Pattern } from '../../index.js';
+/**
+ * Get Canon pattern info for an ESLint rule
+ */
+export declare function getCanonPattern(ruleName: string): Pattern | undefined;
+/**
+ * Format a message with Canon pattern prefix
+ */
+export declare function formatCanonMessage(ruleName: string, message: string): string;
+/**
+ * Get Canon docs metadata for a rule
+ */
+export declare function getCanonDocs(ruleName: string): {
+    canon?: undefined;
+} | {
+    canon: {
+        pattern: string;
+        title: string;
+        url: string;
+    };
+};
+/**
+ * Create a URL for the Canon pattern docs
+ */
+export declare function getCanonUrl(ruleName: string): string;

package/dist/eslint/utils/canon.js

@@ -0,0 +1,50 @@
+import { patterns } from '../../index.js';
+// Build a lookup map from rule name to pattern
+const ruleToPatternMap = new Map();
+for (const pattern of patterns) {
+    if (pattern.rule) {
+        ruleToPatternMap.set(pattern.rule, pattern);
+    }
+}
+/**
+ * Get Canon pattern info for an ESLint rule
+ */
+export function getCanonPattern(ruleName) {
+    return ruleToPatternMap.get(`gallop/${ruleName}`);
+}
+/**
+ * Format a message with Canon pattern prefix
+ */
+export function formatCanonMessage(ruleName, message) {
+    const pattern = getCanonPattern(ruleName);
+    if (pattern) {
+        return `[Canon ${pattern.id}] ${message}`;
+    }
+    return message;
+}
+/**
+ * Get Canon docs metadata for a rule
+ */
+export function getCanonDocs(ruleName) {
+    const pattern = getCanonPattern(ruleName);
+    if (!pattern)
+        return {};
+    return {
+        canon: {
+            pattern: pattern.id,
+            title: pattern.title,
+            url: `https://github.com/gallop-software/canon/blob/main/${pattern.file}`,
+        },
+    };
+}
+/**
+ * Create a URL for the Canon pattern docs
+ */
+export function getCanonUrl(ruleName) {
+    const pattern = getCanonPattern(ruleName);
+    if (pattern) {
+        return `https://github.com/gallop-software/canon/blob/main/${pattern.file}`;
+    }
+    return `https://github.com/gallop-software/canon`;
+}
+//# sourceMappingURL=data:application/json;base64,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