@askviraj/linter 1.1.2 → 1.1.4

package/node_modules/@rviscomi/capo.js/dist/types/lib/options.d.ts

@@ -0,0 +1,114 @@
+export type AssessmentModeValue = 'static' | 'dynamic';
+export type OptionsInit = {
+    preferredAssessmentMode?: AssessmentModeValue;
+    validation?: boolean;
+    palette?: string | string[];
+    loggingPrefix?: string;
+};
+export type OptionsValue = {
+    preferredAssessmentMode: string;
+    validation: boolean;
+    palette: string[];
+    loggingPrefix: string;
+};
+/**
+ * @typedef {'static' | 'dynamic'} AssessmentModeValue
+ *
+ * @typedef {Object} OptionsInit
+ * @property {AssessmentModeValue} [preferredAssessmentMode]
+ * @property {boolean} [validation]
+ * @property {string | string[]} [palette]
+ * @property {string} [loggingPrefix]
+ *
+ * @typedef {Object} OptionsValue
+ * @property {string} preferredAssessmentMode
+ * @property {boolean} validation
+ * @property {string[]} palette
+ * @property {string} loggingPrefix
+ */
+export declare class Options {
+    /** @type {string} */
+    preferredAssessmentMode: string;
+    /** @type {boolean} */
+    validation: boolean;
+    /** @type {string[]} */
+    palette: string[];
+    /** @type {string} */
+    loggingPrefix: string;
+    /**
+     * @param {OptionsInit} [options={}]
+     */
+    constructor({ preferredAssessmentMode, validation, palette, loggingPrefix }?: OptionsInit);
+    /**
+     * @returns {{ STATIC: 'static', DYNAMIC: 'dynamic' }}
+     */
+    static get AssessmentMode(): {
+        STATIC: 'static';
+        DYNAMIC: 'dynamic';
+    };
+    /**
+     * @returns {Record<string, string[]>}
+     */
+    static get Palettes(): Record<string, string[]>;
+    /**
+     * @returns {boolean}
+     */
+    prefersStaticAssessment(): boolean;
+    /**
+     * @returns {boolean}
+     */
+    prefersDynamicAssessment(): boolean;
+    /**
+     * @returns {boolean}
+     */
+    isValidationEnabled(): boolean;
+    /**
+     * @param {string} preferredAssessmentMode
+     */
+    setPreferredAssessmentMode(preferredAssessmentMode: string): void;
+    /**
+     * @param {boolean} prefersStatic
+     */
+    setPreferredAssessmentModeToStatic(prefersStatic: boolean): void;
+    /**
+     * @param {boolean} validation
+     */
+    setValidation(validation: boolean): void;
+    /**
+     * @param {string | string[]} palette
+     */
+    setPalette(palette: string | string[]): void;
+    /**
+     * @param {string} loggingPrefix
+     */
+    setLoggingPrefix(loggingPrefix: string): void;
+    /**
+     * @param {any} assessmentMode
+     * @returns {boolean}
+     */
+    isValidAssessmentMode(assessmentMode: any): boolean;
+    /**
+     * @param {any} validation
+     * @returns {boolean}
+     */
+    isValidValidation(validation: any): boolean;
+    /**
+     * @param {any} palette
+     * @returns {boolean}
+     */
+    isValidPalette(palette: any): boolean;
+    /**
+     * @param {any} loggingPrefix
+     * @returns {boolean}
+     */
+    isValidLoggingPrefix(loggingPrefix: any): boolean;
+    /**
+     * @param {string[]} palette
+     * @returns {boolean}
+     */
+    isPreferredPalette(palette: string[]): boolean;
+    /**
+     * @returns {OptionsValue}
+     */
+    valueOf(): OptionsValue;
+}

package/node_modules/@rviscomi/capo.js/dist/types/lib/rules.d.ts

@@ -0,0 +1,111 @@
+/**
+ * @typedef {import('../adapters/adapter.js').AdapterInterface} AdapterInterface
+ */
+export type AdapterInterface = import('../adapters/adapter.js').AdapterInterface;
+/** @type {Record<string, number>} */
+export declare const ElementWeights: Record<string, number>;
+/** @type {string[]} */
+export declare const META_HTTP_EQUIV_KEYWORDS: string[];
+/**
+ * Check if element is a critical meta/base element
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function isMeta(element: any, adapter: AdapterInterface): boolean;
+/**
+ * Check if element is a title element
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function isTitle(element: any, adapter: AdapterInterface): boolean;
+/**
+ * Check if element is a preconnect link
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function isPreconnect(element: any, adapter: AdapterInterface): boolean;
+/**
+ * Check if element is an async script
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function isAsyncScript(element: any, adapter: AdapterInterface): boolean;
+/**
+ * Check if element is a style element containing CSS import rules
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function isImportStyles(element: any, adapter: AdapterInterface): boolean;
+/**
+ * Check if element is a synchronous script
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function isSyncScript(element: any, adapter: AdapterInterface): boolean;
+/**
+ * Check if element is a synchronous stylesheet or style block
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function isSyncStyles(element: any, adapter: AdapterInterface): boolean;
+/**
+ * Check if element is a preload link
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function isPreload(element: any, adapter: AdapterInterface): boolean;
+/**
+ * Check if element is a deferred script
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function isDeferScript(element: any, adapter: AdapterInterface): boolean;
+/**
+ * Check if element is prefetch/dns-prefetch/prerender link
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function isPrefetchPrerender(element: any, adapter: AdapterInterface): boolean;
+/**
+ * Check if element is an origin trial meta element
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function isOriginTrial(element: any, adapter: AdapterInterface): boolean;
+/**
+ * Check if element is a Content Security Policy meta element
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function isMetaCSP(element: any, adapter: AdapterInterface): boolean;
+/** @type {Record<string, (element: any, adapter: AdapterInterface) => boolean>} */
+export declare const ElementDetectors: Record<string, (element: any, adapter: AdapterInterface) => boolean>;
+/**
+ * Compute weight for an element
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {number}
+ */
+export declare function getWeight(element: any, adapter: AdapterInterface): number;
+/**
+ * Compute weights for all children of head element
+ * @param {any} head
+ * @param {AdapterInterface} adapter
+ * @returns {Array<{ element: any, weight: number }>}
+ */
+export declare function getHeadWeights(head: any, adapter: AdapterInterface): Array<{
+    element: any;
+    weight: number;
+}>;

package/node_modules/@rviscomi/capo.js/dist/types/lib/validation.d.ts

@@ -0,0 +1,61 @@
+export type AdapterInterface = import('../adapters/adapter.js').AdapterInterface;
+export type ValidationWarningResult = {
+    ruleId: string;
+    warning: string;
+    element?: any;
+    elements?: any[];
+};
+export type CustomValidationResult = {
+    ruleId?: string;
+    warnings?: string[];
+    payload?: any;
+    element?: any;
+};
+/**
+ * @typedef {import('../adapters/adapter.js').AdapterInterface} AdapterInterface
+ *
+ * @typedef {Object} ValidationWarningResult
+ * @property {string} ruleId
+ * @property {string} warning
+ * @property {any} [element]
+ * @property {any[]} [elements]
+ *
+ * @typedef {Object} CustomValidationResult
+ * @property {string} [ruleId]
+ * @property {string[]} [warnings]
+ * @property {any} [payload]
+ * @property {any} [element]
+ */
+export declare const VALID_HEAD_ELEMENTS: Set<string>;
+export declare const CONTENT_TYPE_SELECTOR = "meta[http-equiv=\"content-type\" i], meta[charset]";
+export declare const HTTP_EQUIV_SELECTOR = "meta[http-equiv]";
+export declare const PRELOAD_SELECTOR = "link:is([rel=\"preload\" i], [rel=\"modulepreload\" i])";
+/**
+ * Check if element is a valid HTML <head> element
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function isValidElement(element: any, adapter: AdapterInterface): boolean;
+/**
+ * Check if an element has any validation warning
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @returns {boolean}
+ */
+export declare function hasValidationWarning(element: any, adapter: AdapterInterface): boolean;
+/**
+ * Get document-level validation warnings for a <head> element
+ * @param {any} head
+ * @param {AdapterInterface} adapter
+ * @returns {ValidationWarningResult[]}
+ */
+export declare function getValidationWarnings(head: any, adapter: AdapterInterface): ValidationWarningResult[];
+/**
+ * Get custom element-level validations for an element
+ * @param {any} element
+ * @param {AdapterInterface} adapter
+ * @param {any} [parentElement=null]
+ * @returns {CustomValidationResult}
+ */
+export declare function getCustomValidations(element: any, adapter: AdapterInterface, parentElement?: any): CustomValidationResult;

package/node_modules/@rviscomi/capo.js/dist/types/src/adapters/adapter.d.ts

@@ -0,0 +1,105 @@
+/**
+ * @file Base adapter interface for HTML tree operations
+ *
+ * This file defines the contract that all adapters must implement.
+ * Adapters abstract away environment-specific operations (browser DOM vs AST nodes)
+ * to make capo.js core logic reusable across different contexts.
+ */
+export type SourceLocation = {
+    line: number;
+    column: number;
+    endLine?: number;
+    endColumn?: number;
+};
+/**
+ * Base adapter interface
+ *
+ * Actual adapters should implement all these methods.
+ * This serves as both documentation and a reference implementation.
+ *
+ * @example
+ * import { BrowserAdapter } from './browser.js';
+ * import { ParserAdapter } from './parser.js';
+ *
+ * // For browser DOM:
+ * const adapter = new BrowserAdapter();
+ *
+ * // For ESLint HTML parser AST:
+ * const adapter = new ParserAdapter();
+ */
+export declare class AdapterInterface {
+    /**
+     * Check if node is an Element (not text, comment, etc.)
+     * @param {any} node - The node to check
+     * @returns {boolean}
+     */
+    isElement(node: any): boolean;
+    /**
+     * Get the tag name of an element (lowercase)
+     * @param {any} node - Element node
+     * @returns {string} - Tag name like 'meta', 'link', 'script'
+     */
+    getTagName(node: any): string;
+    /**
+     * Get attribute value from element
+     * @param {any} node - Element node
+     * @param {string} attrName - Attribute name (case-insensitive)
+     * @returns {string | null} - Attribute value or null if not found
+     */
+    getAttribute(node: any, attrName: string): string | null;
+    /**
+     * Check if element has a specific attribute
+     * @param {any} node - Element node
+     * @param {string} attrName - Attribute name (case-insensitive)
+     * @returns {boolean} - True if attribute exists
+     */
+    hasAttribute(node: any, attrName: string): boolean;
+    /**
+     * Get all attribute names for an element
+     * @param {any} node - Element node
+     * @returns {string[]} - Array of attribute names
+     */
+    getAttributeNames(node: any): string[];
+    /**
+     * Get text content of a node (for inline scripts/styles)
+     * @param {any} node - Element node
+     * @returns {string} - Text content
+     */
+    getTextContent(node: any): string;
+    /**
+     * Get child elements of a node
+     * @param {any} node - Parent node
+     * @returns {any[]} - Array of child element nodes (excluding text/comment nodes)
+     */
+    getChildren(node: any): any[];
+    /**
+     * Get parent element of a node
+     * @param {any} node - Child node
+     * @returns {any | null} - Parent element node, or null if no parent
+     */
+    getParent(node: any): any | null;
+    /**
+     * Get sibling elements of a node
+     * @param {any} node - Element node
+     * @returns {any[]} - Array of sibling element nodes (excluding the node itself)
+     */
+    getSiblings(node: any): any[];
+    /**
+     * Get source location for a node (optional, for linting)
+     * @param {any} node - Element node
+     * @returns {SourceLocation | null}
+     */
+    getLocation(node: any): SourceLocation | null;
+    /**
+     * Stringify element for logging/debugging
+     * @param {any} node - Element node
+     * @returns {string} - String representation like "<meta charset='utf-8'>"
+     */
+    stringify(node: any): string;
+}
+/**
+ * Validate that an object implements the HTMLAdapter interface
+ * @param {any} adapter - The adapter to validate
+ * @throws {Error} If adapter is missing required methods
+ */
+export declare function validateAdapter(adapter: any): void;

package/node_modules/@rviscomi/capo.js/dist/types/src/adapters/browser.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @file Browser DOM adapter
+ *
+ * Wraps native DOM Element APIs to implement the HTMLAdapter interface.
+ * This adapter is used in browser environments where capo.js operates
+ * on actual DOM elements.
+ */
+import { AdapterInterface } from './adapter.js';
+/**
+ * Browser DOM adapter
+ *
+ * Wraps native DOM Element APIs for use with capo.js core logic.
+ *
+ * @extends AdapterInterface
+ * @example
+ * import { BrowserAdapter } from './adapters/browser.js';
+ * import { analyzeHead } from '../analyzer.js';
+ *
+ * const adapter = new BrowserAdapter();
+ * const head = document.querySelector('head');
+ * const result = analyzeHead(head, adapter);
+ */
+export declare class BrowserAdapter extends AdapterInterface {
+    /**
+     * Check if node is an Element (not text, comment, etc.)
+     * @override
+     * @param {any} node - The node to check
+     * @returns {boolean}
+     */
+    isElement(node: any): boolean;
+    /**
+     * Get the tag name of an element (lowercase)
+     * @override
+     * @param {any} node - Element node
+     * @returns {string} - Tag name like 'meta', 'link', 'script'
+     */
+    getTagName(node: any): string;
+    /**
+     * Get attribute value from element
+     * @override
+     * @param {any} node - Element node
+     * @param {string} attrName - Attribute name (case-insensitive)
+     * @returns {string | null} - Attribute value or null if not found
+     */
+    getAttribute(node: any, attrName: string): string | null;
+    /**
+     * Check if element has a specific attribute
+     * @override
+     * @param {any} node - Element node
+     * @param {string} attrName - Attribute name (case-insensitive)
+     * @returns {boolean} - True if attribute exists
+     */
+    hasAttribute(node: any, attrName: string): boolean;
+    /**
+     * Get all attribute names for an element
+     * @override
+     * @param {any} node - Element node
+     * @returns {string[]} - Array of attribute names
+     */
+    getAttributeNames(node: any): string[];
+    /**
+     * Get text content of a node (for inline scripts/styles)
+     * @override
+     * @param {any} node - Element node
+     * @returns {string} - Text content
+     */
+    getTextContent(node: any): string;
+    /**
+     * Get child elements of a node
+     * @override
+     * @param {any} node - Parent node
+     * @returns {any[]} - Array of child element nodes (excluding text/comment nodes)
+     */
+    getChildren(node: any): any[];
+    /**
+     * Get parent element of a node
+     * @override
+     * @param {any} node - Child node
+     * @returns {any | null} - Parent element node, or null if no parent
+     */
+    getParent(node: any): any | null;
+    /**
+     * Get sibling elements of a node
+     * @override
+     * @param {any} node - Element node
+     * @returns {any[]} - Array of sibling element nodes (excluding the node itself)
+     */
+    getSiblings(node: any): any[];
+    /**
+     * Get source location for a node (optional, for linting)
+     *
+     * Browser DOM elements don't have source location information,
+     * so this always returns null.
+     *
+     * @override
+     * @param {any} node - Element node
+     * @returns {null}
+     */
+    getLocation(node: any): null;
+    /**
+     * Stringify element for logging/debugging
+     * @override
+     * @param {any} node - Element node
+     * @returns {string} - String representation like "<meta charset='utf-8'>"
+     */
+    stringify(node: any): string;
+}

package/node_modules/@rviscomi/capo.js/dist/types/src/adapters/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file Adapter exports
+ *
+ * Central export point for all HTML adapters.
+ */
+export { AdapterInterface, validateAdapter } from './adapter.js';
+export { BrowserAdapter } from './browser.js';

package/node_modules/@rviscomi/capo.js/dist/types/src/adapters/test-suite.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Reusable test suite for adapter validation
+ *
+ * This module provides a standard test suite that can be used to validate
+ * any custom adapter implementation. Consumers can import this and run it
+ * against their own adapters to ensure compliance with the AdapterInterface.
+ *
+ * @example
+ * import { describe } from 'node:test';
+ * import { runAdapterTestSuite } from '@rviscomi/capo.js/adapters/test-suite';
+ * import { MyCustomAdapter } from './my-adapter.js';
+ *
+ * describe('MyCustomAdapter', () => {
+ *   runAdapterTestSuite(MyCustomAdapter, {
+ *     createElement: (html) => {
+ *       // Return a node compatible with your adapter
+ *       return parseHtml(html);
+ *     }
+ *   });
+ * });
+ */
+export type AdapterTestSuiteOptions = {
+    /**
+     * - Function that creates test nodes from HTML strings
+     */
+    createElement: (html: string) => any;
+    /**
+     * - Whether adapter supports getLocation()
+     */
+    supportsLocation?: boolean;
+};
+/**
+ * @typedef {Object} AdapterTestSuiteOptions
+ * @property {(html: string) => any} createElement - Function that creates test nodes from HTML strings
+ * @property {boolean} [supportsLocation=false] - Whether adapter supports getLocation()
+ */
+/**
+ * Run the standard adapter test suite
+ *
+ * @param {new () => any} AdapterClass - The adapter class to test
+ * @param {AdapterTestSuiteOptions} options - Test configuration
+ */
+export declare function runAdapterTestSuite(AdapterClass: new () => any, options: AdapterTestSuiteOptions): void;
+/**
+ * Create a minimal compliance test
+ *
+ * This is a lighter-weight alternative that just checks the adapter
+ * implements all required methods without full behavior testing.
+ *
+ * @param {new () => any} AdapterClass - The adapter class to test
+ */
+export declare function testAdapterCompliance(AdapterClass: new () => any): void;