npm - @askviraj/linter - Versions diffs - 1.1.2 → 1.1.4 - Mend

@askviraj/linter 1.1.2 → 1.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (651) hide show

package/node_modules/@rviscomi/capo.js/dist/types/src/analyzer.d.ts ADDED Viewed

@@ -0,0 +1,195 @@
+/**
+ * Core DOM-agnostic analyzer for capo.js
+ * Provides single-pass analysis of HTML <head> elements
+ *
+ * @module analyzer
+ */
+export type AdapterInterface = import('./adapters/adapter.js').AdapterInterface;
+export type WeightInfo = {
+    /**
+     * - The DOM/AST element
+     */
+    element: any;
+    /**
+     * - Computed weight (0-10)
+     */
+    weight: number;
+};
+export type ValidationWarning = {
+    /**
+     * - The rule identifier
+     */
+    ruleId?: string;
+    /**
+     * - Warning message
+     */
+    warning: string;
+    /**
+     * - Associated element
+     */
+    element?: any;
+    /**
+     * - Associated elements array
+     */
+    elements?: Array<any>;
+};
+export type CustomValidation = {
+    /**
+     * - The rule identifier
+     */
+    ruleId?: string;
+    /**
+     * - The element with validation issues
+     */
+    element: any;
+    /**
+     * - Validation warning messages
+     */
+    warnings: Array<string>;
+    /**
+     * - Extra diagnostic payload
+     */
+    payload?: any;
+};
+export type AnalysisResult = {
+    /**
+     * - Weight information for each element
+     */
+    weights: Array<WeightInfo>;
+    /**
+     * - Document-level validation warnings
+     */
+    validationWarnings: Array<ValidationWarning>;
+    /**
+     * - Element-level validation warnings
+     */
+    customValidations: Array<CustomValidation>;
+    /**
+     * - Reference to the analyzed head element
+     */
+    headElement: any;
+};
+export type OrderingViolation = {
+    index: number;
+    currentElement: any;
+    nextElement: any;
+    currentWeight: number;
+    nextWeight: number;
+    currentCategory: string;
+    nextCategory: string;
+    message: string;
+};
+export type AnalysisResultWithOrdering = AnalysisResult & {
+    orderingViolations: Array<OrderingViolation>;
+};
+export type AnalyzeHeadOptions = {
+    /**
+     * - Whether to include document-level validation warnings
+     */
+    includeValidation?: boolean;
+    /**
+     * - Whether to include element-level custom validations
+     */
+    includeCustomValidations?: boolean;
+};
+/**
+ * @typedef {import('./adapters/adapter.js').AdapterInterface} AdapterInterface
+ *
+ * @typedef {Object} WeightInfo
+ * @property {any} element - The DOM/AST element
+ * @property {number} weight - Computed weight (0-10)
+ */
+/**
+ * @typedef {Object} ValidationWarning
+ * @property {string} [ruleId] - The rule identifier
+ * @property {string} warning - Warning message
+ * @property {any} [element] - Associated element
+ * @property {Array<any>} [elements] - Associated elements array
+ */
+/**
+ * @typedef {Object} CustomValidation
+ * @property {string} [ruleId] - The rule identifier
+ * @property {any} element - The element with validation issues
+ * @property {Array<string>} warnings - Validation warning messages
+ * @property {any} [payload] - Extra diagnostic payload
+ */
+/**
+ * @typedef {Object} AnalysisResult
+ * @property {Array<WeightInfo>} weights - Weight information for each element
+ * @property {Array<ValidationWarning>} validationWarnings - Document-level validation warnings
+ * @property {Array<CustomValidation>} customValidations - Element-level validation warnings
+ * @property {any} headElement - Reference to the analyzed head element
+ */
+/**
+ * @typedef {Object} OrderingViolation
+ * @property {number} index
+ * @property {any} currentElement
+ * @property {any} nextElement
+ * @property {number} currentWeight
+ * @property {number} nextWeight
+ * @property {string} currentCategory
+ * @property {string} nextCategory
+ * @property {string} message
+ */
+/**
+ * @typedef {AnalysisResult & { orderingViolations: Array<OrderingViolation> }} AnalysisResultWithOrdering
+ */
+/**
+ * @typedef {Object} AnalyzeHeadOptions
+ * @property {boolean} [includeValidation=true] - Whether to include document-level validation warnings
+ * @property {boolean} [includeCustomValidations=true] - Whether to include element-level custom validations
+ */
+/**
+ * Analyze the head element and return element weights, validation warnings, and custom validations.
+ *
+ * @param {any} headNode - The head element to analyze
+ * @param {AdapterInterface} adapter - Adapter for element operations
+ * @param {AnalyzeHeadOptions} [options={}] - Analysis options
+ * @returns {AnalysisResult} Analysis results
+ *
+ * @example
+ * const adapter = new BrowserAdapter();
+ * const results = analyzeHead(head, adapter);
+ *
+ * console.log(`Found ${results.weights.length} elements`);
+ * console.log(`${results.validationWarnings.length} document warnings`);
+ */
+export declare function analyzeHead(headNode: any, adapter: AdapterInterface, options?: AnalyzeHeadOptions): AnalysisResult;
+/**
+ * Get weight category name from weight value
+ *
+ * @param {number} weight - Weight value (0-10)
+ * @returns {string} Category name
+ *
+ * @example
+ * getWeightCategory(10); // 'META'
+ * getWeightCategory(9);  // 'TITLE'
+ * getWeightCategory(0);  // 'OTHER'
+ */
+export declare function getWeightCategory(weight: number): string;
+/**
+ * Check if elements are in optimal order
+ *
+ * @param {Array<WeightInfo>} weights - Weight information array
+ * @returns {Array<OrderingViolation>} Array of ordering violations
+ *
+ * @example
+ * const weights = analyzeHead(head, adapter).weights;
+ * const violations = checkOrdering(weights);
+ * console.log(`${violations.length} ordering issues found`);
+ */
+export declare function checkOrdering(weights: Array<WeightInfo>): Array<OrderingViolation>;
+/**
+ * Analyze and return both weights and ordering violations
+ * Convenience function that combines analyzeHead() and checkOrdering()
+ *
+ * @param {any} headNode - The <head> element
+ * @param {AdapterInterface} adapter - HTMLAdapter implementation
+ * @param {AnalyzeHeadOptions} [options={}] - Analysis options
+ * @returns {AnalysisResultWithOrdering} Combined analysis with weights, violations, and validations
+ *
+ * @example
+ * const analysis = analyzeHeadWithOrdering(head, adapter);
+ * console.log(`${analysis.orderingViolations.length} ordering issues`);
+ */
+export declare function analyzeHeadWithOrdering(headNode: any, adapter: AdapterInterface, options?: AnalyzeHeadOptions): AnalysisResultWithOrdering;

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

@@ -0,0 +1,13 @@
+/**
+ * Capo.js v2 - DOM-agnostic HTML <head> analyzer
+ *
+ * Main entry point for programmatic usage.
+ * Exports both the core analyzer API and adapter implementations.
+ *
+ * @module capo
+ */
+export { analyzeHead, analyzeHeadWithOrdering, checkOrdering, getWeightCategory } from './analyzer.js';
+export { ElementWeights, getWeight, getHeadWeights, isMeta, isTitle, isPreconnect, isAsyncScript, isImportStyles, isSyncScript, isSyncStyles, isPreload, isDeferScript, isPrefetchPrerender, isOriginTrial, isMetaCSP } from './lib/rules.js';
+export { VALID_HEAD_ELEMENTS, isValidElement, hasValidationWarning, getValidationWarnings, getCustomValidations } from './lib/validation.js';
+export { BrowserAdapter } from './adapters/browser.js';
+export { AdapterInterface, validateAdapter } from './adapters/adapter.js';

package/node_modules/@rviscomi/capo.js/dist/types/src/lib/colors.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+/**
+ * Generate color swatches for a given hue
+ * @param {number} hue
+ * @returns {string[]}
+ */
+export declare function generateSwatches(hue: number): string[];
+/** @type {string[]} */
+export declare const DEFAULT: string[];
+/** @type {string[]} */
+export declare const PINK: string[];
+/** @type {string[]} */
+export declare const BLUE: string[];
+/** @type {Record<string, string[]>} */
+export declare const Palettes: Record<string, string[]>;
+/**
+ * Get striped background gradient for invalid element visualization
+ * @param {string} elementColor
+ * @returns {string}
+ */
+export declare function getInvalidBackgroundColor(elementColor: string): string;

package/node_modules/@rviscomi/capo.js/dist/types/src/lib/io.d.ts ADDED Viewed

@@ -0,0 +1,166 @@
+export type Options = import('./options.js').Options;
+export type AnalysisResult = import('../analyzer.js').AnalysisResult;
+export type ConsoleOutput = {
+    log: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    groupCollapsed: (...args: any[]) => void;
+    groupEnd: () => void;
+};
+export type HeadWeightInfo = {
+    element?: any;
+    weight: number;
+    isValid?: boolean;
+    customValidations?: Record<string, any>;
+};
+export type ElementVisualization = {
+    visual: string;
+    style: string;
+};
+export type HeadVisualization = {
+    visual: string;
+    styles: string[];
+};
+/**
+ * @typedef {import('./options.js').Options} Options
+ * @typedef {import('../analyzer.js').AnalysisResult} AnalysisResult
+ *
+ * @typedef {Object} ConsoleOutput
+ * @property {(...args: any[]) => void} log
+ * @property {(...args: any[]) => void} warn
+ * @property {(...args: any[]) => void} error
+ * @property {(...args: any[]) => void} groupCollapsed
+ * @property {() => void} groupEnd
+ *
+ * @typedef {Object} HeadWeightInfo
+ * @property {any} [element]
+ * @property {number} weight
+ * @property {boolean} [isValid]
+ * @property {Record<string, any>} [customValidations]
+ *
+ * @typedef {Object} ElementVisualization
+ * @property {string} visual
+ * @property {string} style
+ *
+ * @typedef {Object} HeadVisualization
+ * @property {string} visual
+ * @property {string[]} styles
+ */
+export declare class IO {
+    document: Document | null;
+    options: import("./options.js").Options;
+    console: any;
+    isStaticHead: boolean;
+    /** @type {any} */
+    head: any;
+    /**
+     * @param {Document|null} document
+     * @param {Options} options
+     * @param {ConsoleOutput|any} [output=window.console]
+     */
+    constructor(document: Document | null, options: Options, output?: ConsoleOutput | any);
+    /**
+     * @param {string} html
+     * @returns {string}
+     */
+    static formatStaticHeadHTML(html: string): string;
+    /**
+     * @param {any} head
+     */
+    initFromStaticHead(head: any): void;
+    /**
+     * @param {string} html
+     */
+    initFromHTML(html: string): void;
+    /**
+     * @returns {Promise<void>}
+     */
+    init(): Promise<void>;
+    /**
+     * @returns {Promise<string>}
+     */
+    getStaticHTML(): Promise<string>;
+    /**
+     * @returns {any}
+     */
+    getHead(): any;
+    /**
+     * @param {any} element
+     * @returns {string}
+     */
+    stringifyElement(element: any): string;
+    /**
+     * @param {any} element
+     * @returns {any}
+     */
+    getLoggableElement(element: any): any;
+    /**
+     * Create an element from a CSS selector
+     * @param {string} selector
+     * @returns {any}
+     */
+    createElementFromSelector(selector: string): any;
+    /**
+     * @param {AnalysisResult} result
+     * @returns {HeadWeightInfo[]}
+     */
+    logAnalysis(result: AnalysisResult): HeadWeightInfo[];
+    /**
+     * @param {Object} params
+     * @param {number|string} params.weight
+     * @param {string} params.selector
+     * @param {string} params.html
+     * @param {boolean} [params.isValid]
+     * @param {Record<string, any>} [params.customValidations]
+     */
+    logElementFromSelector({ weight, selector, html, isValid, customValidations }: {
+        weight: number | string;
+        selector: string;
+        html: string;
+        isValid?: boolean;
+        customValidations?: Record<string, any>;
+    }): void;
+    /**
+     * @param {Object} params
+     * @param {ElementVisualization} params.viz
+     * @param {number} params.weight
+     * @param {any} params.element
+     * @param {boolean} [params.isValid]
+     * @param {Record<string, any>} [params.customValidations]
+     * @param {boolean} [params.omitPrefix]
+     */
+    logElement({ viz, weight, element, isValid, customValidations, omitPrefix }: {
+        viz: ElementVisualization;
+        weight: number;
+        element: any;
+        isValid?: boolean;
+        customValidations?: Record<string, any>;
+        omitPrefix?: boolean;
+    }): void;
+    /**
+     * @param {Array<import('../analyzer.js').ValidationWarning>} warnings
+     */
+    logValidationWarnings(warnings: Array<import('../analyzer.js').ValidationWarning>): void;
+    /**
+     * @param {number} weight
+     * @returns {string}
+     */
+    getColor(weight: number): string;
+    /**
+     * @param {HeadWeightInfo[]} elements
+     * @returns {HeadVisualization}
+     */
+    getHeadVisualization(elements: HeadWeightInfo[]): HeadVisualization;
+    /**
+     * @param {number} weight
+     * @param {boolean} [isValid=true]
+     * @returns {ElementVisualization}
+     */
+    getElementVisualization(weight: number, isValid?: boolean): ElementVisualization;
+    /**
+     * @param {string} groupName
+     * @param {any} headElement
+     * @param {HeadWeightInfo[]} headWeights
+     */
+    visualizeHead(groupName: string, headElement: any, headWeights: HeadWeightInfo[]): void;
+}

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

@@ -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/src/lib/rules.d.ts ADDED Viewed

@@ -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/src/lib/validation.d.ts ADDED Viewed

@@ -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;