@jesscss/plugin-less-compat 2.0.0-alpha.7 → 2.0.0-alpha.9

package/lib/less-compat-structures.cjs

@@ -1,378 +0,0 @@
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_less_adapter = require("./less-adapter.cjs");
-//#region src/less-compat-structures.ts
-/**
-* Minimal Less.js-compatible structures for plugin compatibility
-* These are standalone implementations that don't require the actual Less.js library
-*/
-/**
-* Less.js Visitor base class (minimal implementation)
-* Plugins expect this structure to exist
-*/
-var LessVisitor = class {
-	processingNodes = /* @__PURE__ */ new WeakSet();
-	constructor(visitor) {
-		this.visitor = visitor;
-	}
-	/**
-	* Visit a node - handles both modern and legacy Less.js node types
-	* Supports Less.js v2 "Directive" nodes (mapped to AtRule)
-	*
-	* In Less.js v2, at-rules were called "Directive" instead of "AtRule".
-	* For compatibility, we route AtRule nodes to visitDirective() if that method exists,
-	* allowing v2 plugins to work with modern AtRule nodes.
-	*/
-	visit(node, visitArgs) {
-		if (!node) return node;
-		if (typeof node !== "object") return node;
-		if (!this.visitor) return node;
-		if (this.processingNodes.has(node)) return node;
-		this.processingNodes.add(node);
-		const args = visitArgs || { visitDeeper: true };
-		if (args.visitDeeper === void 0) args.visitDeeper = true;
-		const nodeType = node.type;
-		if (!nodeType || typeof nodeType !== "string") {
-			if (typeof this.visitor.visit === "function") {
-				const result = this.visitor.visit(node, args);
-				if (args.visitDeeper && node && node.accept) node.accept(this);
-				return result;
-			}
-			return node;
-		}
-		const visitMethodName = `visit${nodeType}`;
-		let result = node;
-		let visitMethod;
-		if (typeof this.visitor[visitMethodName] === "function") visitMethod = this.visitor[visitMethodName];
-		else if (nodeType === "Directive" || nodeType === "AtRule") {
-			if (typeof this.visitor.visitDirective === "function") visitMethod = this.visitor.visitDirective;
-			else if (typeof this.visitor.visitAtRule === "function") visitMethod = this.visitor.visitAtRule;
-		} else if (nodeType === "Rule") {
-			if (typeof this.visitor.visitRule === "function") visitMethod = this.visitor.visitRule;
-			else if (typeof this.visitor.visitDeclaration === "function") visitMethod = this.visitor.visitDeclaration;
-		} else if (nodeType === "Reference") {
-			if (typeof this.visitor.visitVariable === "function") visitMethod = this.visitor.visitVariable;
-			else if (typeof this.visitor.visitReference === "function") visitMethod = this.visitor.visitReference;
-		}
-		if (visitMethod) {
-			result = visitMethod.call(this.visitor, node, args);
-			if (this.visitor.isReplacing && result !== void 0) node = result;
-		} else if (typeof this.visitor.visit === "function") {
-			result = this.visitor.visit(node, args);
-			if (this.visitor.isReplacing && result !== void 0) node = result;
-		}
-		if (args.visitDeeper && node && node.accept) {
-			if (node instanceof require_less_adapter.LessAdapterBase) node.accept(this);
-		}
-		return result;
-	}
-	/**
-	* Visit array of nodes
-	*/
-	visitArray(nodes, visitArgs) {
-		if (!nodes) return nodes;
-		return nodes.map((node) => this.visit(node, visitArgs));
-	}
-	/**
-	* Visit Directive node (Less.js v2 compatibility)
-	* Maps to AtRule for modern Less.js compatibility
-	*/
-	visitDirective(node, visitArgs) {
-		if (node && node.type === "Directive") {
-			if (this.visitor && typeof this.visitor.visitDirective === "function") return this.visitor.visitDirective(node, visitArgs);
-			if (this.visitor && typeof this.visitor.visitAtRule === "function") return this.visitor.visitAtRule(node, visitArgs);
-		}
-		return this.visit(node, visitArgs);
-	}
-	/**
-	* Visit Rule node (Less.js v2 compatibility)
-	* Maps to Declaration for modern Less.js compatibility
-	*/
-	visitRule(node, visitArgs) {
-		if (node && (node.type === "Rule" || node.type === "Declaration")) {
-			if (this.visitor && typeof this.visitor.visitRule === "function") return this.visitor.visitRule(node, visitArgs);
-			if (this.visitor && typeof this.visitor.visitDeclaration === "function") return this.visitor.visitDeclaration(node, visitArgs);
-		}
-		return this.visit(node, visitArgs);
-	}
-};
-/**
-* Less.js PluginManager (minimal implementation)
-* Plugins use this to register visitors, pre/post processors, etc.
-*/
-var LessPluginManager = class {
-	visitors = [];
-	preProcessors = [];
-	postProcessors = [];
-	constructor(less, newFactory) {
-		this.less = less;
-		this.newFactory = newFactory;
-	}
-	/**
-	* Add a visitor to the manager
-	*/
-	addVisitor(visitor) {
-		this.visitors.push(visitor);
-	}
-	/**
-	* Remove a visitor
-	*/
-	removeVisitor(visitor) {
-		const index = this.visitors.indexOf(visitor);
-		if (index > -1) this.visitors.splice(index, 1);
-	}
-	/**
-	* Add a pre-processor (runs before parsing)
-	*/
-	addPreProcessor(preProcessor) {
-		this.preProcessors.push(preProcessor);
-	}
-	/**
-	* Add a post-processor (runs after compilation)
-	*/
-	addPostProcessor(postProcessor) {
-		this.postProcessors.push(postProcessor);
-	}
-	/**
-	* Get all visitors
-	*/
-	getVisitors() {
-		return this.visitors;
-	}
-	/**
-	* Get all pre-processors
-	*/
-	getPreProcessors() {
-		return this.preProcessors;
-	}
-	/**
-	* Get all post-processors
-	*/
-	getPostProcessors() {
-		return this.postProcessors;
-	}
-	/**
-	* Register a plugin (Less.js-compatible API)
-	* Some plugins use this method instead of install()
-	*/
-	registerPlugin(plugin, _options) {
-		if (!plugin) return;
-		if (typeof plugin.install === "function") plugin.install(this.less, this, this.less.functions.functionRegistry);
-		if ((typeof plugin.visit === "function" || typeof plugin.visitRuleset === "function") && !this.visitors.includes(plugin)) this.addVisitor(plugin);
-	}
-};
-/**
-* Less.js tree constructors (minimal implementations)
-* Plugins may access these via functionRegistry.Call, etc.
-*/
-const LessTreeConstructors = {
-	Anonymous: function(value, index, fileInfo) {
-		return {
-			type: "Anonymous",
-			value,
-			index: index || 0,
-			fileInfo: fileInfo || {},
-			accept: function(visitor) {
-				return visitor.visit(this);
-			},
-			toCSS: function() {
-				return String(value);
-			}
-		};
-	},
-	Quoted: function(quote, value, escaped, index, fileInfo) {
-		return {
-			type: "Quoted",
-			quote,
-			value,
-			escaped: !!escaped,
-			index: index || 0,
-			fileInfo: fileInfo || {},
-			accept: function(visitor) {
-				return visitor.visit(this);
-			},
-			toCSS: function() {
-				return `${quote}${String(value)}${quote}`;
-			}
-		};
-	},
-	DetachedRuleset: function(ruleset) {
-		return {
-			type: "DetachedRuleset",
-			ruleset,
-			accept: function(visitor) {
-				return visitor.visit(this);
-			}
-		};
-	},
-	Call: function(name, args, index, fileInfo) {
-		return {
-			type: "Call",
-			name,
-			args: args || [],
-			index: index || 0,
-			fileInfo: fileInfo || {},
-			value: null,
-			accept: function(visitor) {
-				return visitor.visit(this);
-			}
-		};
-	},
-	Variable: function(name, index, fileInfo) {
-		return {
-			type: "Variable",
-			name,
-			index: index || 0,
-			fileInfo: fileInfo || {},
-			value: null,
-			accept: function(visitor) {
-				return visitor.visit(this);
-			}
-		};
-	},
-	VariableCall: function(name, index, fileInfo) {
-		return {
-			type: "VariableCall",
-			name,
-			index: index || 0,
-			fileInfo: fileInfo || {},
-			value: null,
-			accept: function(visitor) {
-				return visitor.visit(this);
-			}
-		};
-	},
-	Ruleset: function(selectors, rules, strictImports, visibilityInfo, fileInfo) {
-		return {
-			type: "Ruleset",
-			selectors: selectors || [],
-			rules: rules || [],
-			strictImports,
-			visibilityInfo,
-			fileInfo: fileInfo || {},
-			accept: function(visitor) {
-				return visitor.visit(this);
-			}
-		};
-	},
-	Declaration: function(name, value, index, fileInfo, variable, important) {
-		return {
-			type: "Declaration",
-			name,
-			value,
-			index: index || 0,
-			fileInfo: fileInfo || {},
-			variable: variable || false,
-			important: important || "",
-			accept: function(visitor) {
-				return visitor.visit(this);
-			}
-		};
-	},
-	Dimension: function(value, unit) {
-		return {
-			type: "Dimension",
-			value,
-			unit: unit || "",
-			accept: function(visitor) {
-				return visitor.visit(this);
-			}
-		};
-	},
-	Color: function(rgb, alpha) {
-		let rgbArray;
-		if (typeof rgb === "string") {
-			const hex = rgb.replace(/^#/, "");
-			rgbArray = (hex.length >= 6 ? hex.match(/.{2}/g) ?? [] : hex.split("").map((c) => c + c)).slice(0, 3).map((c) => parseInt(c, 16));
-		} else rgbArray = rgb || [
-			0,
-			0,
-			0
-		];
-		return {
-			type: "Color",
-			rgb: rgbArray,
-			alpha: alpha !== void 0 ? alpha : 1,
-			accept: function(visitor) {
-				return visitor.visit(this);
-			}
-		};
-	},
-	Directive: function(name, value, rules, index, fileInfo) {
-		return {
-			type: "Directive",
-			name: name || "",
-			value: value || null,
-			rules: rules || [],
-			index: index || 0,
-			fileInfo: fileInfo || {},
-			isCharset: function() {
-				return this.name === "@charset" || this.name === "charset";
-			},
-			isRulesetLike: function() {
-				return this.rules && this.rules.length > 0;
-			},
-			accept: function(visitor) {
-				if (visitor.visitDirective) return visitor.visitDirective(this);
-				if (visitor.visitAtRule) return visitor.visitAtRule(this);
-				return visitor.visit(this);
-			}
-		};
-	},
-	Rule: function(name, value, important, merge, index, fileInfo, inline, variable) {
-		return {
-			type: "Rule",
-			name: name || "",
-			value: value || null,
-			important: important || "",
-			merge: merge || false,
-			index: index || 0,
-			fileInfo: fileInfo || {},
-			inline: inline || false,
-			variable: variable !== void 0 ? variable : name && name.charAt && name.charAt(0) === "@",
-			accept: function(visitor) {
-				if (visitor.visitRule) return visitor.visitRule(this);
-				if (visitor.visitDeclaration) return visitor.visitDeclaration(this);
-				return visitor.visit(this);
-			}
-		};
-	}
-};
-/**
-* Create a Less.js-compatible mock object
-* This provides the minimal structure that plugins expect
-*/
-function createLessMock(functionRegistry) {
-	return {
-		visitors: { Visitor: LessVisitor },
-		functions: { functionRegistry },
-		tree: LessTreeConstructors,
-		PluginLoader: class {},
-		dimension(value, unit) {
-			return LessTreeConstructors.Dimension(value, unit);
-		},
-		value(values) {
-			return values;
-		},
-		declaration(name, value) {
-			return LessTreeConstructors.Declaration(name, value);
-		},
-		ruleset(selector, rules) {
-			return LessTreeConstructors.Ruleset([selector], rules);
-		},
-		detachedruleset(rulesetLike) {
-			return LessTreeConstructors.DetachedRuleset(rulesetLike);
-		},
-		atrule(name, value) {
-			return {
-				type: "AtRule",
-				name,
-				value
-			};
-		}
-	};
-}
-//#endregion
-exports.LessPluginManager = LessPluginManager;
-exports.LessTreeConstructors = LessTreeConstructors;
-exports.LessVisitor = LessVisitor;
-exports.createLessMock = createLessMock;

package/lib/less-compat-structures.d.ts

@@ -1,108 +0,0 @@
-/**
- * Minimal Less.js-compatible structures for plugin compatibility
- * These are standalone implementations that don't require the actual Less.js library
- */
-export declare class LessVisitor {
-    visitor?: any;
-    private processingNodes;
-    constructor(visitor?: any);
-    /**
-     * Visit a node - handles both modern and legacy Less.js node types
-     * Supports Less.js v2 "Directive" nodes (mapped to AtRule)
-     *
-     * In Less.js v2, at-rules were called "Directive" instead of "AtRule".
-     * For compatibility, we route AtRule nodes to visitDirective() if that method exists,
-     * allowing v2 plugins to work with modern AtRule nodes.
-     */
-    visit(node: any, visitArgs?: any): any;
-    /**
-     * Visit array of nodes
-     */
-    visitArray(nodes: any[], visitArgs?: any): any[];
-    /**
-     * Visit Directive node (Less.js v2 compatibility)
-     * Maps to AtRule for modern Less.js compatibility
-     */
-    visitDirective(node: any, visitArgs?: any): any;
-    /**
-     * Visit Rule node (Less.js v2 compatibility)
-     * Maps to Declaration for modern Less.js compatibility
-     */
-    visitRule(node: any, visitArgs?: any): any;
-}
-/**
- * Less.js PluginManager (minimal implementation)
- * Plugins use this to register visitors, pre/post processors, etc.
- */
-export declare class LessPluginManager {
-    less: any;
-    newFactory?: boolean | undefined;
-    visitors: any[];
-    preProcessors: any[];
-    postProcessors: any[];
-    constructor(less: any, newFactory?: boolean | undefined);
-    /**
-     * Add a visitor to the manager
-     */
-    addVisitor(visitor: any): void;
-    /**
-     * Remove a visitor
-     */
-    removeVisitor(visitor: any): void;
-    /**
-     * Add a pre-processor (runs before parsing)
-     */
-    addPreProcessor(preProcessor: any): void;
-    /**
-     * Add a post-processor (runs after compilation)
-     */
-    addPostProcessor(postProcessor: any): void;
-    /**
-     * Get all visitors
-     */
-    getVisitors(): any[];
-    /**
-     * Get all pre-processors
-     */
-    getPreProcessors(): any[];
-    /**
-     * Get all post-processors
-     */
-    getPostProcessors(): any[];
-    /**
-     * Register a plugin (Less.js-compatible API)
-     * Some plugins use this method instead of install()
-     */
-    registerPlugin(plugin: any, _options?: any): void;
-}
-/**
- * Less.js tree constructors (minimal implementations)
- * Plugins may access these via functionRegistry.Call, etc.
- */
-export declare const LessTreeConstructors: Record<string, any>;
-/**
- * Create a Less.js-compatible mock object
- * This provides the minimal structure that plugins expect
- */
-export declare function createLessMock(functionRegistry: any): {
-    visitors: {
-        Visitor: typeof LessVisitor;
-    };
-    functions: {
-        functionRegistry: any;
-    };
-    tree: Record<string, any>;
-    PluginLoader: {
-        new (): {};
-    };
-    dimension(value: number, unit?: string): any;
-    value(values: any[]): any[];
-    declaration(name: string, value: any): any;
-    ruleset(selector: any, rules: any[]): any;
-    detachedruleset(rulesetLike: any): any;
-    atrule(name: string, value: any): {
-        type: string;
-        name: string;
-        value: any;
-    };
-};