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

package/lib/less-adapter.cjs

@@ -0,0 +1,216 @@
+//#region src/transform/type-map.ts
+/**
+* Type mapping utilities for converting between Jess and Less node types
+*/
+/**
+* Map Jess node types to Less node types
+*
+* @param jessType - The Jess node type
+* @returns The corresponding Less node type
+*/
+function mapJessTypeToLessType(jessType) {
+	return {
+		Ruleset: "Ruleset",
+		Declaration: "Declaration",
+		SelectorList: "Selector",
+		ComplexSelector: "Selector",
+		CompoundSelector: "Selector",
+		BasicSelector: "Element",
+		Combinator: "Combinator",
+		AttributeSelector: "Attribute",
+		Dimension: "Dimension",
+		Num: "Dimension",
+		Reference: "Variable",
+		Mixin: "MixinDefinition",
+		Call: "Call",
+		Operation: "Operation",
+		Expression: "Expression",
+		Sequence: "Expression",
+		Quoted: "Quoted",
+		Url: "URL",
+		Color: "Color",
+		Comment: "Comment",
+		AtRule: "AtRule",
+		StyleImport: "Import",
+		Extend: "Extend",
+		Condition: "Condition",
+		Paren: "Paren",
+		Negative: "Negative",
+		List: "Value",
+		VarDeclaration: "Assignment",
+		Keyword: "Keyword"
+	}[jessType] || jessType;
+}
+/**
+* Map Less node types to Jess node types
+*
+* @param lessType - The Less node type
+* @returns The corresponding Jess node type
+*/
+function mapLessTypeToJessType(lessType) {
+	return {
+		Ruleset: "Ruleset",
+		Declaration: "Declaration",
+		Selector: "SelectorList",
+		Element: "BasicSelector",
+		Combinator: "Combinator",
+		Attribute: "AttributeSelector",
+		Dimension: "Dimension",
+		Variable: "Reference",
+		Property: "Reference",
+		VariableCall: "Reference",
+		MixinDefinition: "Mixin",
+		MixinCall: "Call",
+		Call: "Call",
+		Operation: "Operation",
+		Expression: "Expression",
+		Quoted: "Quoted",
+		URL: "Url",
+		Color: "Color",
+		Comment: "Comment",
+		AtRule: "AtRule",
+		Directive: "AtRule",
+		Rule: "Declaration",
+		Import: "StyleImport",
+		Extend: "Extend",
+		Condition: "Condition",
+		Paren: "Paren",
+		Negative: "Negative",
+		Value: "List",
+		Assignment: "VarDeclaration",
+		Keyword: "Keyword"
+	}[lessType] || lessType;
+}
+/**
+* Get Less typeIndex for a Jess node type
+*
+* Less.js uses typeIndex for visitor caching. This function
+* maps Jess types to their corresponding Less typeIndex values.
+*
+* @param jessType - The Jess node type
+* @returns The Less typeIndex, or undefined if not found
+*/
+function getLessTypeIndex$1(_jessType) {}
+//#endregion
+//#region src/transform/less-adapter.ts
+const LESS_ADAPTER_SYMBOL = Symbol("less-adapter");
+const JESS_NODE_SYMBOL = Symbol("jess-node");
+const ACTIVE_ADAPTATIONS = /* @__PURE__ */ new WeakSet();
+function getLessTypeIndex(_lessType) {}
+function normalizeField(field) {
+	if (typeof field === "function") return { get: field };
+	return field;
+}
+var LessAdapterBase = class {
+	[LESS_ADAPTER_SYMBOL] = true;
+	[JESS_NODE_SYMBOL];
+	constructor(node) {
+		this[JESS_NODE_SYMBOL] = node;
+		Object.defineProperty(this, "__jessNode", {
+			enumerable: false,
+			configurable: false,
+			writable: false,
+			value: node
+		});
+	}
+	get jessNode() {
+		return this.__jessNode;
+	}
+};
+var LessNodeAdapter = class extends LessAdapterBase {
+	lessType;
+	cache;
+	acceptImpl;
+	constructor(node, definition, cache) {
+		super(node);
+		this.lessType = definition.lessType;
+		this.cache = cache;
+		this.acceptImpl = definition.accept;
+		Object.defineProperties(this, {
+			type: {
+				enumerable: true,
+				configurable: true,
+				get: () => {
+					if (typeof this.lessType === "function") return this.lessType(this.jessNode);
+					return this.lessType ?? mapJessTypeToLessType(this.jessNode.type);
+				}
+			},
+			typeIndex: {
+				enumerable: true,
+				configurable: true,
+				get: () => {
+					return getLessTypeIndex(typeof this.lessType === "function" ? this.lessType(this.jessNode) : this.lessType ?? mapJessTypeToLessType(this.jessNode.type));
+				}
+			},
+			accept: {
+				enumerable: false,
+				configurable: true,
+				value: (visitor) => {
+					if (this.acceptImpl) return this.acceptImpl(this.jessNode, visitor, this.cache);
+					return this.jessNode;
+				}
+			}
+		});
+		for (const [key, rawField] of Object.entries(definition.fields ?? {})) {
+			const field = normalizeField(rawField);
+			Object.defineProperty(this, key, {
+				enumerable: field.enumerable ?? true,
+				configurable: true,
+				get: () => field.get(this.jessNode, this.cache),
+				set: field.set ? (value) => field.set(this.jessNode, value, this.cache) : void 0
+			});
+		}
+	}
+};
+function createLessAdapter(jessNode, definition, cache) {
+	const cached = cache?.get(jessNode);
+	if (cached instanceof LessNodeAdapter) return cached;
+	ACTIVE_ADAPTATIONS.add(jessNode);
+	try {
+		const adapter = new LessNodeAdapter(jessNode, definition, cache);
+		cache?.set(jessNode, adapter);
+		return adapter;
+	} finally {
+		ACTIVE_ADAPTATIONS.delete(jessNode);
+	}
+}
+function isAdaptingNode(node) {
+	return ACTIVE_ADAPTATIONS.has(node);
+}
+//#endregion
+Object.defineProperty(exports, "LessAdapterBase", {
+	enumerable: true,
+	get: function() {
+		return LessAdapterBase;
+	}
+});
+Object.defineProperty(exports, "createLessAdapter", {
+	enumerable: true,
+	get: function() {
+		return createLessAdapter;
+	}
+});
+Object.defineProperty(exports, "getLessTypeIndex", {
+	enumerable: true,
+	get: function() {
+		return getLessTypeIndex$1;
+	}
+});
+Object.defineProperty(exports, "isAdaptingNode", {
+	enumerable: true,
+	get: function() {
+		return isAdaptingNode;
+	}
+});
+Object.defineProperty(exports, "mapJessTypeToLessType", {
+	enumerable: true,
+	get: function() {
+		return mapJessTypeToLessType;
+	}
+});
+Object.defineProperty(exports, "mapLessTypeToJessType", {
+	enumerable: true,
+	get: function() {
+		return mapLessTypeToJessType;
+	}
+});

package/lib/less-adapter.js

@@ -0,0 +1,181 @@
+//#region src/transform/type-map.ts
+/**
+* Type mapping utilities for converting between Jess and Less node types
+*/
+/**
+* Map Jess node types to Less node types
+*
+* @param jessType - The Jess node type
+* @returns The corresponding Less node type
+*/
+function mapJessTypeToLessType(jessType) {
+	return {
+		Ruleset: "Ruleset",
+		Declaration: "Declaration",
+		SelectorList: "Selector",
+		ComplexSelector: "Selector",
+		CompoundSelector: "Selector",
+		BasicSelector: "Element",
+		Combinator: "Combinator",
+		AttributeSelector: "Attribute",
+		Dimension: "Dimension",
+		Num: "Dimension",
+		Reference: "Variable",
+		Mixin: "MixinDefinition",
+		Call: "Call",
+		Operation: "Operation",
+		Expression: "Expression",
+		Sequence: "Expression",
+		Quoted: "Quoted",
+		Url: "URL",
+		Color: "Color",
+		Comment: "Comment",
+		AtRule: "AtRule",
+		StyleImport: "Import",
+		Extend: "Extend",
+		Condition: "Condition",
+		Paren: "Paren",
+		Negative: "Negative",
+		List: "Value",
+		VarDeclaration: "Assignment",
+		Keyword: "Keyword"
+	}[jessType] || jessType;
+}
+/**
+* Map Less node types to Jess node types
+*
+* @param lessType - The Less node type
+* @returns The corresponding Jess node type
+*/
+function mapLessTypeToJessType(lessType) {
+	return {
+		Ruleset: "Ruleset",
+		Declaration: "Declaration",
+		Selector: "SelectorList",
+		Element: "BasicSelector",
+		Combinator: "Combinator",
+		Attribute: "AttributeSelector",
+		Dimension: "Dimension",
+		Variable: "Reference",
+		Property: "Reference",
+		VariableCall: "Reference",
+		MixinDefinition: "Mixin",
+		MixinCall: "Call",
+		Call: "Call",
+		Operation: "Operation",
+		Expression: "Expression",
+		Quoted: "Quoted",
+		URL: "Url",
+		Color: "Color",
+		Comment: "Comment",
+		AtRule: "AtRule",
+		Directive: "AtRule",
+		Rule: "Declaration",
+		Import: "StyleImport",
+		Extend: "Extend",
+		Condition: "Condition",
+		Paren: "Paren",
+		Negative: "Negative",
+		Value: "List",
+		Assignment: "VarDeclaration",
+		Keyword: "Keyword"
+	}[lessType] || lessType;
+}
+/**
+* Get Less typeIndex for a Jess node type
+*
+* Less.js uses typeIndex for visitor caching. This function
+* maps Jess types to their corresponding Less typeIndex values.
+*
+* @param jessType - The Jess node type
+* @returns The Less typeIndex, or undefined if not found
+*/
+function getLessTypeIndex$1(_jessType) {}
+//#endregion
+//#region src/transform/less-adapter.ts
+const LESS_ADAPTER_SYMBOL = Symbol("less-adapter");
+const JESS_NODE_SYMBOL = Symbol("jess-node");
+const ACTIVE_ADAPTATIONS = /* @__PURE__ */ new WeakSet();
+function getLessTypeIndex(_lessType) {}
+function normalizeField(field) {
+	if (typeof field === "function") return { get: field };
+	return field;
+}
+var LessAdapterBase = class {
+	[LESS_ADAPTER_SYMBOL] = true;
+	[JESS_NODE_SYMBOL];
+	constructor(node) {
+		this[JESS_NODE_SYMBOL] = node;
+		Object.defineProperty(this, "__jessNode", {
+			enumerable: false,
+			configurable: false,
+			writable: false,
+			value: node
+		});
+	}
+	get jessNode() {
+		return this.__jessNode;
+	}
+};
+var LessNodeAdapter = class extends LessAdapterBase {
+	lessType;
+	cache;
+	acceptImpl;
+	constructor(node, definition, cache) {
+		super(node);
+		this.lessType = definition.lessType;
+		this.cache = cache;
+		this.acceptImpl = definition.accept;
+		Object.defineProperties(this, {
+			type: {
+				enumerable: true,
+				configurable: true,
+				get: () => {
+					if (typeof this.lessType === "function") return this.lessType(this.jessNode);
+					return this.lessType ?? mapJessTypeToLessType(this.jessNode.type);
+				}
+			},
+			typeIndex: {
+				enumerable: true,
+				configurable: true,
+				get: () => {
+					return getLessTypeIndex(typeof this.lessType === "function" ? this.lessType(this.jessNode) : this.lessType ?? mapJessTypeToLessType(this.jessNode.type));
+				}
+			},
+			accept: {
+				enumerable: false,
+				configurable: true,
+				value: (visitor) => {
+					if (this.acceptImpl) return this.acceptImpl(this.jessNode, visitor, this.cache);
+					return this.jessNode;
+				}
+			}
+		});
+		for (const [key, rawField] of Object.entries(definition.fields ?? {})) {
+			const field = normalizeField(rawField);
+			Object.defineProperty(this, key, {
+				enumerable: field.enumerable ?? true,
+				configurable: true,
+				get: () => field.get(this.jessNode, this.cache),
+				set: field.set ? (value) => field.set(this.jessNode, value, this.cache) : void 0
+			});
+		}
+	}
+};
+function createLessAdapter(jessNode, definition, cache) {
+	const cached = cache?.get(jessNode);
+	if (cached instanceof LessNodeAdapter) return cached;
+	ACTIVE_ADAPTATIONS.add(jessNode);
+	try {
+		const adapter = new LessNodeAdapter(jessNode, definition, cache);
+		cache?.set(jessNode, adapter);
+		return adapter;
+	} finally {
+		ACTIVE_ADAPTATIONS.delete(jessNode);
+	}
+}
+function isAdaptingNode(node) {
+	return ACTIVE_ADAPTATIONS.has(node);
+}
+//#endregion
+export { mapJessTypeToLessType as a, getLessTypeIndex$1 as i, createLessAdapter as n, mapLessTypeToJessType as o, isAdaptingNode as r, LessAdapterBase as t };