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

package/lib/less-compat-structures.cjs

@@ -0,0 +1,378 @@
+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

@@ -3,9 +3,9 @@
  * These are standalone implementations that don't require the actual Less.js library
  */
 export declare class LessVisitor {
-    visitor?: any | undefined;
+    visitor?: any;
     private processingNodes;
-    constructor(visitor?: any | undefined);
+    constructor(visitor?: any);
     /**
      * Visit a node - handles both modern and legacy Less.js node types
      * Supports Less.js v2 "Directive" nodes (mapped to AtRule)