@jesscss/plugin-less-compat 2.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Matthew Dean
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,139 @@
+# @jesscss/plugin-less-compat
+
+Less.js compatibility layer for Jess. This plugin enables Less.js plugins and visitors to work seamlessly with Jess-compiled stylesheets by providing bidirectional transformation between Jess AST nodes and Less.js AST nodes.
+
+## ⚠️ Experimental Status
+
+**This package is experimental and largely LLM-generated.** It was created to explore compatibility between Jess and Less.js plugins, but:
+
+- **No long-term maintenance commitment**: This package is unlikely to be actively maintained in the future
+- **Use at your own risk**: While it may work for some use cases, it has not been thoroughly tested across all Less.js plugins
+- **Breaking changes likely**: The API and implementation may change or be removed without notice
+- **Not production-ready**: This is an experimental exploration, not a production-grade compatibility layer
+
+If you need Less.js plugin compatibility, consider:
+- Using Less.js directly for projects that require extensive Less.js plugin support
+- Contributing improvements if you find this package useful
+- Creating your own compatibility layer tailored to your specific needs
+
+## Features
+
+- 🔄 **Bidirectional Transformation**: Convert between Jess and Less AST nodes
+- 🎯 **Lazy Conversion**: Proxy-based lazy conversion for optimal performance
+- 🔌 **Plugin Compatibility**: Use existing Less.js plugins with Jess
+- 🧩 **Visitor Support**: Run Less.js visitors on Jess AST trees
+- 📦 **Type Safe**: Full TypeScript support
+
+## Installation
+
+```bash
+pnpm add @jesscss/plugin-less-compat
+```
+
+## Usage
+
+### Basic Usage with Less Plugins
+
+```typescript
+import { Compiler } from '@jesscss/jess';
+import lessPlugin from '@jesscss/plugin-less';
+import { lessCompatPlugin } from '@jesscss/plugin-less-compat';
+import autoprefix from 'less-plugin-autoprefix';
+
+const compiler = new Compiler({
+  plugins: [
+    lessPlugin(),
+    lessCompatPlugin({
+      visitors: [autoprefix]
+    })
+  ]
+});
+
+const result = await compiler.compile('styles.less');
+```
+
+### Advanced: Direct Transformation
+
+```typescript
+import { toLessTree, fromLessTree } from '@jesscss/plugin-less-compat/transform';
+import customLessVisitor from './custom-visitor';
+
+const jessTree = parseJess(source);
+const lessTree = toLessTree(jessTree);
+
+// Apply custom Less visitor
+lessTree.accept(customLessVisitor);
+
+// Convert back to Jess
+const modifiedJessTree = fromLessTree(lessTree);
+```
+
+### Using with Multiple Less Plugins
+
+```typescript
+import { lessCompatPlugin } from '@jesscss/plugin-less-compat';
+import autoprefix from 'less-plugin-autoprefix';
+import cleanCSS from 'less-plugin-clean-css';
+
+const compiler = new Compiler({
+  plugins: [
+    lessPlugin(),
+    lessCompatPlugin({
+      visitors: [
+        autoprefix,
+        cleanCSS
+      ]
+    })
+  ]
+});
+```
+
+## Supported Less Plugins
+
+This package has been tested with:
+
+- ✅ `less-plugin-autoprefix` - Automatic vendor prefixing
+- ✅ `less-plugin-clean-css` - CSS minification
+- ✅ `less-plugin-dls` - Design Language System support
+
+Other Less.js plugins should work, but may require additional testing.
+
+## API
+
+### `lessCompatPlugin(options?)`
+
+Creates a Jess plugin that enables Less.js compatibility.
+
+**Options:**
+- `visitors?: LessVisitor[]` - Array of Less.js visitors to apply
+- `cache?: boolean` - Enable conversion caching (default: `true`)
+
+### `toLessTree(jessRules: Rules)`
+
+Converts a Jess `Rules` tree to a Less.js-compatible tree.
+
+### `fromLessTree(lessTree: LessNode)`
+
+Converts a Less.js tree back to a Jess `Rules` tree.
+
+### `toLessNode(jessNode: Node, options?)`
+
+Converts a single Jess node to a Less.js-compatible node.
+
+### `fromLessNode(lessNode: LessNode, options?)`
+
+Converts a single Less.js node back to a Jess node.
+
+## Implementation Status
+
+This package is currently in **alpha**.
+
+Developer notes and historical analyses live in [DESIGN.md](./DESIGN.md) and `_archive/`.
+
+## Contributing
+
+Contributions welcome! Please see the main Jess repository for contribution guidelines.
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @jesscss/plugin-less-compat
+ *
+ * Less.js compatibility layer for Jess.
+ * Enables Less.js plugins and visitors to work with Jess AST.
+ */
+export { LessCompatPlugin, default as lessCompatPlugin, type LessCompatPluginOptions } from './plugin.js';
+export * from './transform/index.js';
+export { isLessPlugin, isJessPlugin, filterPlugins } from './plugin-utils.js';

package/lib/index.js

@@ -0,0 +1,10 @@
+/**
+ * @jesscss/plugin-less-compat
+ *
+ * Less.js compatibility layer for Jess.
+ * Enables Less.js plugins and visitors to work with Jess AST.
+ */
+export { LessCompatPlugin, default as lessCompatPlugin } from './plugin.js';
+export * from './transform/index.js';
+export { isLessPlugin, isJessPlugin, filterPlugins } from './plugin-utils.js';
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,gBAAgB,EAAE,OAAO,IAAI,gBAAgB,EAAgC,MAAM,aAAa,CAAC;AAC1G,cAAc,sBAAsB,CAAC;AACrC,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC"}

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

@@ -0,0 +1,108 @@
+/**
+ * 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 | undefined;
+    private processingNodes;
+    constructor(visitor?: any | undefined);
+    /**
+     * 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;
+    };
+};