@weapp-tailwindcss/css-compat 0.0.0-stage → 0.1.0

package/dist/layers.cjs

@@ -0,0 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_layers = require("./layers-CT2GtJgP.cjs");
+exports.compileCascadeLayers = require_layers.compileCascadeLayers;
+exports.createCascadeLayersPlugin = require_layers.createCascadeLayersPlugin;

package/dist/layers.d.cts

@@ -0,0 +1,17 @@
+import { CascadeLayerDiagnostic } from "./diagnostics.cjs";
+import { Plugin, Root } from "postcss";
+//#region src/layers.d.ts
+export interface CascadeLayerOptions {
+  mode: 'ordered' | 'preserve';
+  onConflict?: 'warning' | 'error' | undefined;
+  inputStage?: 'native' | 'polyfilled' | undefined;
+}
+export interface CascadeLayerCompilation {
+  root: Root;
+  diagnostics: CascadeLayerDiagnostic[];
+}
+/** 只编译当前 Root 的级联作用域；错误时不修改输入 AST。 */
+export declare function compileCascadeLayers(root: Root, options: CascadeLayerOptions): CascadeLayerCompilation;
+/** 在其他插件完成 import/nesting 后编译，并将定位诊断交给 PostCSS。 */
+export declare function createCascadeLayersPlugin(options: CascadeLayerOptions): Plugin;
+//#endregion

package/dist/layers.d.mts

@@ -0,0 +1,17 @@
+import { CascadeLayerDiagnostic } from "./diagnostics.mjs";
+import { Plugin, Root } from "postcss";
+//#region src/layers.d.ts
+export interface CascadeLayerOptions {
+  mode: 'ordered' | 'preserve';
+  onConflict?: 'warning' | 'error' | undefined;
+  inputStage?: 'native' | 'polyfilled' | undefined;
+}
+export interface CascadeLayerCompilation {
+  root: Root;
+  diagnostics: CascadeLayerDiagnostic[];
+}
+/** 只编译当前 Root 的级联作用域；错误时不修改输入 AST。 */
+export declare function compileCascadeLayers(root: Root, options: CascadeLayerOptions): CascadeLayerCompilation;
+/** 在其他插件完成 import/nesting 后编译，并将定位诊断交给 PostCSS。 */
+export declare function createCascadeLayersPlugin(options: CascadeLayerOptions): Plugin;
+//#endregion

package/dist/layers.mjs

@@ -0,0 +1,2 @@
+import { n as createCascadeLayersPlugin, t as compileCascadeLayers } from "./layers-D0OJtr2q.mjs";
+export { compileCascadeLayers, createCascadeLayersPlugin };

package/dist/legacy.cjs

@@ -0,0 +1,160 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("./rolldown-runtime-y5ARvAq5.cjs");
+let postcss = require("postcss");
+postcss = require_rolldown_runtime.__toESM(postcss, 1);
+//#region src/legacy.ts
+const LAYER_PATH_SEPARATOR = "
";
+const LAYER_INSERTION_ANCHOR = "__weapp_tailwindcss_layer_anchor__";
+function splitLayerNames(params) {
+	return params.split(",").map((name) => name.trim()).filter(Boolean);
+}
+function splitLayerPath(name) {
+	return name.split(".").map((segment) => segment.trim()).filter(Boolean);
+}
+function createLayerPath(segments) {
+	return {
+		key: segments.join(LAYER_PATH_SEPARATOR),
+		segments
+	};
+}
+function isContainer(node) {
+	return "nodes" in node && Array.isArray(node.nodes);
+}
+function cloneWrapper(node, children) {
+	const wrapper = node.clone({ nodes: [] });
+	wrapper.append(...children);
+	return wrapper;
+}
+function wrapLayerNodes(atRule, nodes, root) {
+	let wrapped = nodes;
+	let parent = atRule.parent;
+	while (parent && parent !== root) {
+		if (parent.type !== "atrule" || parent.name !== "layer") {
+			if (isContainer(parent)) wrapped = [cloneWrapper(parent, wrapped)];
+		}
+		parent = parent.parent;
+	}
+	return wrapped;
+}
+function removeEmptyLayerAncestors(node, root) {
+	let parent = node.parent;
+	node.remove();
+	while (parent && parent !== root && parent.type === "atrule" && parent.nodes?.length === 0) {
+		const nextParent = parent.parent;
+		parent.remove();
+		parent = nextParent;
+	}
+}
+function isLayerDescendant(candidate, parent) {
+	return candidate.length > parent.length && parent.every((segment, index) => candidate[index] === segment);
+}
+function findParentLayerPath(atRule, paths) {
+	let parent = atRule.parent;
+	while (parent) {
+		if (parent.type === "atrule" && parent.name === "layer") return paths.get(parent)?.segments ?? [];
+		parent = parent.parent;
+	}
+	return [];
+}
+function createLayerInsertionAnchor(root, atRule) {
+	let topLevelNode = atRule;
+	while (topLevelNode.parent && topLevelNode.parent !== root) topLevelNode = topLevelNode.parent;
+	const anchor = postcss.default.comment({ text: LAYER_INSERTION_ANCHOR });
+	topLevelNode.before(anchor);
+	return anchor;
+}
+function insertLayeredNodes(root, anchor, nodes) {
+	if (!anchor.parent) {
+		root.append(nodes);
+		return;
+	}
+	if (nodes.length === 0) {
+		anchor.remove();
+		return;
+	}
+	anchor.replaceWith(nodes);
+}
+/**
+* 按 cascade layer 声明顺序重排规则并移除 `@layer` 语法。
+*
+* 该转换只模拟 layer 的顺序语义，不通过提高选择器权重模拟完整 specificity 规则。
+*/
+function consumeCascadeLayers(root) {
+	const layerAtRules = [];
+	const paths = /* @__PURE__ */ new WeakMap();
+	const siblingOrders = /* @__PURE__ */ new Map();
+	const buckets = /* @__PURE__ */ new Map();
+	const topLayerOccurrences = /* @__PURE__ */ new Map();
+	let anonymousLayerIndex = 0;
+	const registerPath = (segments, occurrence) => {
+		let parentKey = "";
+		for (const [index, segment] of segments.entries()) {
+			let siblings = siblingOrders.get(parentKey);
+			if (!siblings) {
+				siblings = /* @__PURE__ */ new Map();
+				siblingOrders.set(parentKey, siblings);
+			}
+			if (!siblings.has(segment)) siblings.set(segment, siblings.size);
+			if (index === 0 && !topLayerOccurrences.has(segment)) topLayerOccurrences.set(segment, occurrence);
+			parentKey = parentKey ? `${parentKey}${LAYER_PATH_SEPARATOR}${segment}` : segment;
+		}
+		const path = createLayerPath(segments);
+		if (!buckets.has(path.key)) buckets.set(path.key, {
+			...path,
+			nodes: []
+		});
+		return path;
+	};
+	root.walkAtRules("layer", (atRule) => {
+		layerAtRules.push(atRule);
+		const parentLayer = findParentLayerPath(atRule, paths);
+		const names = splitLayerNames(atRule.params);
+		if (!atRule.nodes) {
+			for (const name of names) registerPath([...parentLayer, ...splitLayerPath(name)], atRule);
+			return;
+		}
+		const ownSegments = names[0] ? splitLayerPath(names[0]) : [`\u0000anonymous-${anonymousLayerIndex++}`];
+		paths.set(atRule, registerPath([...parentLayer, ...ownSegments], atRule));
+	});
+	if (layerAtRules.length === 0) return;
+	const insertionAnchors = /* @__PURE__ */ new Map();
+	for (const [segment, occurrence] of topLayerOccurrences) insertionAnchors.set(segment, createLayerInsertionAnchor(root, occurrence));
+	for (const atRule of [...layerAtRules].reverse()) {
+		if (!atRule.parent) continue;
+		const path = paths.get(atRule);
+		if (!path || !atRule.nodes) {
+			removeEmptyLayerAncestors(atRule, root);
+			continue;
+		}
+		const nodes = atRule.nodes.map((node) => node.clone());
+		if (nodes.length > 0) buckets.get(path.key)?.nodes.unshift(...wrapLayerNodes(atRule, nodes, root));
+		removeEmptyLayerAncestors(atRule, root);
+	}
+	const compareBuckets = (left, right) => {
+		if (isLayerDescendant(left.segments, right.segments)) return -1;
+		if (isLayerDescendant(right.segments, left.segments)) return 1;
+		const size = Math.min(left.segments.length, right.segments.length);
+		let parentKey = "";
+		for (let index = 0; index < size; index++) {
+			const leftSegment = left.segments[index];
+			const rightSegment = right.segments[index];
+			if (leftSegment !== rightSegment) {
+				const siblings = siblingOrders.get(parentKey);
+				return (siblings?.get(leftSegment) ?? 0) - (siblings?.get(rightSegment) ?? 0);
+			}
+			parentKey = parentKey ? `${parentKey}${LAYER_PATH_SEPARATOR}${leftSegment}` : leftSegment;
+		}
+		return left.segments.length - right.segments.length;
+	};
+	const bucketsByTopLayer = /* @__PURE__ */ new Map();
+	for (const bucket of buckets.values()) {
+		const topLayer = bucket.segments[0];
+		if (!topLayer || bucket.nodes.length === 0) continue;
+		const group = bucketsByTopLayer.get(topLayer) ?? [];
+		group.push(bucket);
+		bucketsByTopLayer.set(topLayer, group);
+	}
+	for (const [segment, anchor] of insertionAnchors) insertLayeredNodes(root, anchor, (bucketsByTopLayer.get(segment) ?? []).sort(compareBuckets).flatMap((bucket) => bucket.nodes));
+}
+//#endregion
+exports.consumeCascadeLayers = consumeCascadeLayers;

package/dist/legacy.d.cts

@@ -0,0 +1,9 @@
+import { Root } from "postcss";
+//#region src/legacy.d.ts
+/**
+ * 按 cascade layer 声明顺序重排规则并移除 `@layer` 语法。
+ *
+ * 该转换只模拟 layer 的顺序语义，不通过提高选择器权重模拟完整 specificity 规则。
+ */
+export declare function consumeCascadeLayers(root: Root): void;
+//#endregion

package/dist/legacy.d.mts

@@ -0,0 +1,9 @@
+import { Root } from "postcss";
+//#region src/legacy.d.ts
+/**
+ * 按 cascade layer 声明顺序重排规则并移除 `@layer` 语法。
+ *
+ * 该转换只模拟 layer 的顺序语义，不通过提高选择器权重模拟完整 specificity 规则。
+ */
+export declare function consumeCascadeLayers(root: Root): void;
+//#endregion

package/dist/legacy.mjs

@@ -0,0 +1,157 @@
+import postcss from "postcss";
+//#region src/legacy.ts
+const LAYER_PATH_SEPARATOR = "
";
+const LAYER_INSERTION_ANCHOR = "__weapp_tailwindcss_layer_anchor__";
+function splitLayerNames(params) {
+	return params.split(",").map((name) => name.trim()).filter(Boolean);
+}
+function splitLayerPath(name) {
+	return name.split(".").map((segment) => segment.trim()).filter(Boolean);
+}
+function createLayerPath(segments) {
+	return {
+		key: segments.join(LAYER_PATH_SEPARATOR),
+		segments
+	};
+}
+function isContainer(node) {
+	return "nodes" in node && Array.isArray(node.nodes);
+}
+function cloneWrapper(node, children) {
+	const wrapper = node.clone({ nodes: [] });
+	wrapper.append(...children);
+	return wrapper;
+}
+function wrapLayerNodes(atRule, nodes, root) {
+	let wrapped = nodes;
+	let parent = atRule.parent;
+	while (parent && parent !== root) {
+		if (parent.type !== "atrule" || parent.name !== "layer") {
+			if (isContainer(parent)) wrapped = [cloneWrapper(parent, wrapped)];
+		}
+		parent = parent.parent;
+	}
+	return wrapped;
+}
+function removeEmptyLayerAncestors(node, root) {
+	let parent = node.parent;
+	node.remove();
+	while (parent && parent !== root && parent.type === "atrule" && parent.nodes?.length === 0) {
+		const nextParent = parent.parent;
+		parent.remove();
+		parent = nextParent;
+	}
+}
+function isLayerDescendant(candidate, parent) {
+	return candidate.length > parent.length && parent.every((segment, index) => candidate[index] === segment);
+}
+function findParentLayerPath(atRule, paths) {
+	let parent = atRule.parent;
+	while (parent) {
+		if (parent.type === "atrule" && parent.name === "layer") return paths.get(parent)?.segments ?? [];
+		parent = parent.parent;
+	}
+	return [];
+}
+function createLayerInsertionAnchor(root, atRule) {
+	let topLevelNode = atRule;
+	while (topLevelNode.parent && topLevelNode.parent !== root) topLevelNode = topLevelNode.parent;
+	const anchor = postcss.comment({ text: LAYER_INSERTION_ANCHOR });
+	topLevelNode.before(anchor);
+	return anchor;
+}
+function insertLayeredNodes(root, anchor, nodes) {
+	if (!anchor.parent) {
+		root.append(nodes);
+		return;
+	}
+	if (nodes.length === 0) {
+		anchor.remove();
+		return;
+	}
+	anchor.replaceWith(nodes);
+}
+/**
+* 按 cascade layer 声明顺序重排规则并移除 `@layer` 语法。
+*
+* 该转换只模拟 layer 的顺序语义，不通过提高选择器权重模拟完整 specificity 规则。
+*/
+function consumeCascadeLayers(root) {
+	const layerAtRules = [];
+	const paths = /* @__PURE__ */ new WeakMap();
+	const siblingOrders = /* @__PURE__ */ new Map();
+	const buckets = /* @__PURE__ */ new Map();
+	const topLayerOccurrences = /* @__PURE__ */ new Map();
+	let anonymousLayerIndex = 0;
+	const registerPath = (segments, occurrence) => {
+		let parentKey = "";
+		for (const [index, segment] of segments.entries()) {
+			let siblings = siblingOrders.get(parentKey);
+			if (!siblings) {
+				siblings = /* @__PURE__ */ new Map();
+				siblingOrders.set(parentKey, siblings);
+			}
+			if (!siblings.has(segment)) siblings.set(segment, siblings.size);
+			if (index === 0 && !topLayerOccurrences.has(segment)) topLayerOccurrences.set(segment, occurrence);
+			parentKey = parentKey ? `${parentKey}${LAYER_PATH_SEPARATOR}${segment}` : segment;
+		}
+		const path = createLayerPath(segments);
+		if (!buckets.has(path.key)) buckets.set(path.key, {
+			...path,
+			nodes: []
+		});
+		return path;
+	};
+	root.walkAtRules("layer", (atRule) => {
+		layerAtRules.push(atRule);
+		const parentLayer = findParentLayerPath(atRule, paths);
+		const names = splitLayerNames(atRule.params);
+		if (!atRule.nodes) {
+			for (const name of names) registerPath([...parentLayer, ...splitLayerPath(name)], atRule);
+			return;
+		}
+		const ownSegments = names[0] ? splitLayerPath(names[0]) : [`\u0000anonymous-${anonymousLayerIndex++}`];
+		paths.set(atRule, registerPath([...parentLayer, ...ownSegments], atRule));
+	});
+	if (layerAtRules.length === 0) return;
+	const insertionAnchors = /* @__PURE__ */ new Map();
+	for (const [segment, occurrence] of topLayerOccurrences) insertionAnchors.set(segment, createLayerInsertionAnchor(root, occurrence));
+	for (const atRule of [...layerAtRules].reverse()) {
+		if (!atRule.parent) continue;
+		const path = paths.get(atRule);
+		if (!path || !atRule.nodes) {
+			removeEmptyLayerAncestors(atRule, root);
+			continue;
+		}
+		const nodes = atRule.nodes.map((node) => node.clone());
+		if (nodes.length > 0) buckets.get(path.key)?.nodes.unshift(...wrapLayerNodes(atRule, nodes, root));
+		removeEmptyLayerAncestors(atRule, root);
+	}
+	const compareBuckets = (left, right) => {
+		if (isLayerDescendant(left.segments, right.segments)) return -1;
+		if (isLayerDescendant(right.segments, left.segments)) return 1;
+		const size = Math.min(left.segments.length, right.segments.length);
+		let parentKey = "";
+		for (let index = 0; index < size; index++) {
+			const leftSegment = left.segments[index];
+			const rightSegment = right.segments[index];
+			if (leftSegment !== rightSegment) {
+				const siblings = siblingOrders.get(parentKey);
+				return (siblings?.get(leftSegment) ?? 0) - (siblings?.get(rightSegment) ?? 0);
+			}
+			parentKey = parentKey ? `${parentKey}${LAYER_PATH_SEPARATOR}${leftSegment}` : leftSegment;
+		}
+		return left.segments.length - right.segments.length;
+	};
+	const bucketsByTopLayer = /* @__PURE__ */ new Map();
+	for (const bucket of buckets.values()) {
+		const topLayer = bucket.segments[0];
+		if (!topLayer || bucket.nodes.length === 0) continue;
+		const group = bucketsByTopLayer.get(topLayer) ?? [];
+		group.push(bucket);
+		bucketsByTopLayer.set(topLayer, group);
+	}
+	for (const [segment, anchor] of insertionAnchors) insertLayeredNodes(root, anchor, (bucketsByTopLayer.get(segment) ?? []).sort(compareBuckets).flatMap((bucket) => bucket.nodes));
+}
+//#endregion
+export { consumeCascadeLayers };

package/dist/rolldown-runtime-y5ARvAq5.cjs

@@ -0,0 +1,35 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__commonJSMin", {
+	enumerable: true,
+	get: function() {
+		return __commonJSMin;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/package.json

@@ -1,6 +1,99 @@
 {
   "name": "@weapp-tailwindcss/css-compat",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "type": "module",
+  "version": "0.1.0",
+  "description": "框架无关的 CSS layer 顺序编译、诊断与显式旧算法兼容。",
+  "author": "ice breaker <1324318532@qq.com>",
+  "license": "MIT",
+  "homepage": "https://tw.weapp.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/weapp-tailwindcss/weapp-tailwindcss.git",
+    "directory": "packages/css-compat"
+  },
+  "bugs": {
+    "url": "https://github.com/weapp-tailwindcss/weapp-tailwindcss/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./layers": {
+      "import": {
+        "types": "./dist/layers.d.mts",
+        "default": "./dist/layers.mjs"
+      },
+      "require": {
+        "types": "./dist/layers.d.cts",
+        "default": "./dist/layers.cjs"
+      }
+    },
+    "./diagnostics": {
+      "import": {
+        "types": "./dist/diagnostics.d.mts",
+        "default": "./dist/diagnostics.mjs"
+      },
+      "require": {
+        "types": "./dist/diagnostics.d.cts",
+        "default": "./dist/diagnostics.cjs"
+      }
+    },
+    "./legacy": {
+      "import": {
+        "types": "./dist/legacy.d.mts",
+        "default": "./dist/legacy.mjs"
+      },
+      "require": {
+        "types": "./dist/legacy.d.cts",
+        "default": "./dist/legacy.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "README.md",
+    "README.zh-CN.md",
+    "THIRD_PARTY_LICENSES.txt",
+    "dist"
+  ],
+  "engines": {
+    "node": "^22.18.0 || >=24.11.0"
+  },
+  "peerDependencies": {
+    "postcss": "^8.5.29"
+  },
+  "dependencies": {
+    "@csstools/css-tokenizer": "^4.0.1",
+    "@csstools/selector-specificity": "6.0.1",
+    "postcss-selector-parser": "^7.1.6"
+  },
+  "devDependencies": {
+    "mdn-data": "2.37.2"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run --update=none",
+    "typecheck": "tsc -p tsconfig.json --noEmit --pretty false",
+    "test:package": "node scripts/verify-package.mjs",
+    "test:consumers": "node scripts/verify-consumers.mjs",
+    "test:browser": "node scripts/browser-parity.mjs",
+    "bench": "node --expose-gc scripts/benchmark.mjs",
+    "properties:generate": "node scripts/generate-properties.mjs",
+    "properties:check": "node scripts/generate-properties.mjs --check",
+    "lint": "eslint src scripts"
+  }
 }