vite-plugin-qingkuai 1.0.1 → 1.0.3

package/dist/index.cjs

@@ -0,0 +1,333 @@
+'use strict';
+
+var node_path = require('node:path');
+var node_fs = require('node:fs');
+var node_crypto = require('node:crypto');
+var sourceMapJs = require('source-map-js');
+var sourcemapCodec = require('@jridgewell/sourcemap-codec');
+var compiler = require('qingkuai/compiler');
+var postcss = require('postcss');
+var selectorParser = require('postcss-selector-parser');
+var vite = require('vite');
+
+function findFilesByName(dir, targetFileName, ignoreList) {
+  const result = [];
+  const entries = node_fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (ignoreList.has(entry.name)) {
+      continue;
+    }
+    const fullPath = node_path.join(dir, entry.name);
+    if (entry.name === targetFileName) {
+      result.push(fullPath);
+    } else if (entry.isDirectory()) {
+      result.push(...findFilesByName(fullPath, targetFileName, ignoreList));
+    }
+  }
+  return result;
+}
+
+function offsetSourceMap(mappings, sourceIndex, preLine, preColumn) {
+  return sourcemapCodec.decode(mappings).map((line) => {
+    return line.map((segment) => {
+      if (segment.length === 1 || segment[1] !== sourceIndex) {
+        return segment;
+      }
+      if (segment[2] === preLine) {
+        segment[3] += preColumn;
+      } else {
+        segment[2] += preLine;
+      }
+      return segment;
+    });
+  });
+}
+function getSourceFile(sourcemap, line, column) {
+  const consumer = new sourceMapJs.SourceMapConsumer({
+    ...sourcemap,
+    version: sourcemap.version.toString()
+  });
+  return consumer.originalPositionFor({
+    line,
+    column
+  }).source;
+}
+
+async function attachScopeForStyleSelectors(code, hash, map, sourceFile) {
+  const processor = postcss([
+    {
+      postcssPlugin: "postcss-attach-scope-qingkuai",
+      Rule(rule) {
+        const { line, column } = rule.source.start;
+        if (getSourceFile(map, line, column) !== sourceFile) {
+          return;
+        }
+        rule.selector = selectorParser((selectors) => {
+          selectors.each((selector) => {
+            const index = selector.nodes.findLastIndex(({ type }) => {
+              return type === "class" || type === "tag" || type === "id" || type === "universal";
+            });
+            if (index !== -1) {
+              const lastNode = selector.nodes[index];
+              lastNode.parent?.insertAfter(
+                lastNode,
+                selectorParser.attribute({
+                  attribute: `qk-${hash}`,
+                  value: void 0,
+                  raws: {}
+                })
+              );
+            }
+          });
+        }).processSync(rule.selector);
+      }
+    }
+  ]);
+  const ret = await processor.process(code, {
+    from: map.file,
+    map: {
+      prev: map,
+      annotation: false
+    }
+  });
+  return { code: ret.css, mappings: ret.map.toJSON().mappings };
+}
+
+function qingkuaiPlugin() {
+  let isDev;
+  let sourcemap;
+  let cssSourcemap;
+  let viteConfig;
+  const compileResultCache = /* @__PURE__ */ new Map();
+  const qingkuaiConfigurations = /* @__PURE__ */ new Map();
+  const qingkuaiPackageServeRE = /node_modules\/\.vite\/deps\/chunk.*$/;
+  const confIdentifierRE = /__qk_expose_(?:dependencies|destructions)__/g;
+  const styleIdRE = /^virtual:\[\d+\].*?\.qk.(?:css|s[ac]ss|less|stylus|postcss)\?\d{13}$/;
+  const qingkuaiPackageBuildRE = /node_modules\/qingkuai\/dist\/esm\/(?:chunks|runtime)\/\w+\.js$/;
+  return {
+    name: "qingkuai-compiler",
+    config(_, env) {
+      isDev = env.command === "serve";
+    },
+    configureServer(server) {
+      createQingkuaiConfigurationWatcher(server);
+    },
+    configResolved(config) {
+      viteConfig = config;
+      if (isDev) {
+        sourcemap = true;
+        cssSourcemap = !!config.css.devSourcemap;
+      } else {
+        cssSourcemap = true;
+        sourcemap = config.build.sourcemap !== false;
+      }
+      loadAllQingkuaiConfigurations(config.root);
+    },
+    resolveId(id, importer) {
+      if (styleIdRE.test(id)) {
+        return id;
+      }
+      if (importer?.endsWith(".qk") && !node_path.extname(id)) {
+        const qingkuaiConfig = getQingkuaiConfiguration(id);
+        return id + (qingkuaiConfig.resolveImportExtension ? ".qk" : "");
+      }
+    },
+    async load(id) {
+      if (styleIdRE.test(id)) {
+        const { fileId, index } = parseStyleId(id);
+        if (index === -1) {
+          return "";
+        }
+        let virtualFileName;
+        const compileRes = compileResultCache.get(fileId);
+        const style = compileRes.inputDescriptor.styles[index];
+        while (true) {
+          const hash = node_crypto.randomBytes(6).toString("hex");
+          virtualFileName = `${fileId}.${hash}.${style.lang}`;
+          if (!node_fs.existsSync(virtualFileName)) {
+            break;
+          }
+        }
+        const preprocessRes = await vite.preprocessCSS(style.code, virtualFileName, {
+          ...viteConfig,
+          css: {
+            ...viteConfig.css,
+            postcss: {
+              from: virtualFileName
+            }
+          }
+        });
+        if (!cssSourcemap) {
+          return preprocessRes.code;
+        }
+        const assertedPreprocessMap = preprocessRes.map;
+        const attachScopeResult = await attachScopeForStyleSelectors(
+          preprocessRes.code,
+          compileRes.hashId,
+          assertedPreprocessMap,
+          virtualFileName
+        );
+        const offsetMappings = sourcemapCodec.encode(
+          offsetSourceMap(
+            attachScopeResult.mappings,
+            preprocessRes.deps?.size || 0,
+            style.loc.start.line - 1,
+            style.loc.start.column - 1
+          )
+        );
+        return {
+          code: attachScopeResult.code,
+          map: {
+            version: 3,
+            mappings: offsetMappings,
+            names: assertedPreprocessMap.names,
+            sources: [...assertedPreprocessMap.sources.slice(0, -1), fileId]
+          }
+        };
+      }
+    },
+    async transform(src, id) {
+      const qingkuaiConfig = getQingkuaiConfiguration(id);
+      if (!id.endsWith(".qk")) {
+        if (isDev && qingkuaiPackageServeRE.test(id) || !isDev && qingkuaiPackageBuildRE.test(id)) {
+          const ret = src.replace(confIdentifierRE, (s) => {
+            switch (s) {
+              case "__qk_expose_dependencies__":
+                return JSON.stringify(!!qingkuaiConfig.exposeDependencies);
+              case "__qk_expose_destructions__":
+                return JSON.stringify(!!qingkuaiConfig.exposeDestructions);
+              default:
+                return s;
+            }
+          });
+          return ret;
+        }
+        return;
+      }
+      const compileRes = compiler.compile(src, {
+        sourcemap,
+        debug: isDev,
+        hashId: compileResultCache.get(id)?.hashId || void 0,
+        reserveTemplateComment: getReserveHtmlComments(qingkuaiConfig),
+        componentName: compiler.util.kebab2Camel(node_path.basename(id, node_path.extname(id)), true)
+      });
+      compileRes.messages.forEach(({ type, value: warning }) => {
+        if (type === "warning") {
+          this.warn(warning.message);
+        }
+      });
+      compileResultCache.set(id, compileRes);
+      const compiledCodeArr = [compileRes.code];
+      compileRes.inputDescriptor.styles.forEach((_, index) => {
+        compiledCodeArr.push(`import "virtual:[${index}]${id}.css?${Date.now()}"`);
+      });
+      const baseMap = {
+        version: 3,
+        sources: [id],
+        sourcesContent: [src]
+      };
+      const compiledCode = compiledCodeArr.join("\n");
+      if (!compileRes.inputDescriptor.script.isTS) {
+        if (!sourcemap) {
+          return compiledCode;
+        }
+        return {
+          code: compiledCode,
+          map: Object.assign(baseMap, {
+            mappings: compileRes.mappings
+          })
+        };
+      }
+      const esBuildCompileRes = await vite.transformWithEsbuild(
+        compiledCode,
+        id,
+        {
+          sourcemap,
+          loader: "ts",
+          target: "esnext"
+        },
+        sourcemap ? {
+          version: 3,
+          sources: [id],
+          sourcesContent: [src],
+          mappings: compileRes.mappings
+        } : void 0
+      );
+      if (!sourcemap) {
+        return esBuildCompileRes.code;
+      }
+      return {
+        code: esBuildCompileRes.code,
+        map: Object.assign(baseMap, {
+          mappings: esBuildCompileRes.map.mappings
+        })
+      };
+    }
+  };
+  function getQingkuaiConfiguration(id) {
+    let config = {
+      insertTipComments: true,
+      exposeDestructions: isDev,
+      exposeDependencies: isDev,
+      resolveImportExtension: true,
+      reserveHtmlComments: "development"
+    };
+    while (true) {
+      const dir = node_path.dirname(id);
+      if (dir === id) {
+        break;
+      }
+      const got = qingkuaiConfigurations.get(id = dir);
+      if (got) {
+        config = got;
+        break;
+      }
+    }
+    return config;
+  }
+  function getReserveHtmlComments(config) {
+    switch (config.reserveHtmlComments) {
+      case "all":
+        return true;
+      case "never":
+        return false;
+      case "production":
+        return !isDev;
+      default:
+        return isDev;
+    }
+  }
+  function createQingkuaiConfigurationWatcher(server) {
+    const watcher = server.watcher.add([".qingkuairc", "!**/node_modules/**"]);
+    watcher.on("unlink", (path) => qingkuaiConfigurations.delete(node_path.dirname(path)));
+    watcher.on("change", recordQingkuaiConfiguration);
+    watcher.on("add", recordQingkuaiConfiguration);
+  }
+  function loadAllQingkuaiConfigurations(workspaceDir) {
+    findFilesByName(workspaceDir, ".qingkuairc", /* @__PURE__ */ new Set(["node_modules"])).forEach((fileName) => {
+      recordQingkuaiConfiguration(fileName);
+    });
+  }
+  function recordQingkuaiConfiguration(fileName) {
+    try {
+      qingkuaiConfigurations.set(node_path.dirname(fileName), JSON.parse(node_fs.readFileSync(fileName, "utf-8")));
+    } catch {
+    }
+  }
+}
+function parseStyleId(id) {
+  const m1 = /^virtual:\[(\d+)\]/.exec(id);
+  const m2 = /\.[a-z]+\?\d{13}$/.exec(id);
+  if (!m1 || !m2) {
+    return {
+      index: -1,
+      fileId: ""
+    };
+  }
+  return {
+    index: parseInt(m1[1]),
+    fileId: id.slice(m1.index + m1[0].length, m2.index)
+  };
+}
+
+module.exports = qingkuaiPlugin;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { Plugin } from 'vite';
+
+declare function qingkuaiPlugin(): Plugin;
+
+export { qingkuaiPlugin as default };

package/dist/index.js

@@ -0,0 +1,332 @@
+import { join, basename, extname, dirname } from 'node:path';
+import { readdirSync, existsSync, readFileSync } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { SourceMapConsumer } from 'source-map-js';
+import { decode, encode } from '@jridgewell/sourcemap-codec';
+import { compile, util } from 'qingkuai/compiler';
+import postcss from 'postcss';
+import selectorParser from 'postcss-selector-parser';
+import { transformWithEsbuild, preprocessCSS } from 'vite';
+
+function findFilesByName(dir, targetFileName, ignoreList) {
+  const result = [];
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (ignoreList.has(entry.name)) {
+      continue;
+    }
+    const fullPath = join(dir, entry.name);
+    if (entry.name === targetFileName) {
+      result.push(fullPath);
+    } else if (entry.isDirectory()) {
+      result.push(...findFilesByName(fullPath, targetFileName, ignoreList));
+    }
+  }
+  return result;
+}
+
+function offsetSourceMap(mappings, sourceIndex, preLine, preColumn) {
+  return decode(mappings).map((line) => {
+    return line.map((segment) => {
+      if (segment.length === 1 || segment[1] !== sourceIndex) {
+        return segment;
+      }
+      if (segment[2] === preLine) {
+        segment[3] += preColumn;
+      } else {
+        segment[2] += preLine;
+      }
+      return segment;
+    });
+  });
+}
+function getSourceFile(sourcemap, line, column) {
+  const consumer = new SourceMapConsumer({
+    ...sourcemap,
+    version: sourcemap.version.toString()
+  });
+  return consumer.originalPositionFor({
+    line,
+    column
+  }).source;
+}
+
+async function attachScopeForStyleSelectors(code, hash, map, sourceFile) {
+  const processor = postcss([
+    {
+      postcssPlugin: "postcss-attach-scope-qingkuai",
+      Rule(rule) {
+        const { line, column } = rule.source.start;
+        if (getSourceFile(map, line, column) !== sourceFile) {
+          return;
+        }
+        rule.selector = selectorParser((selectors) => {
+          selectors.each((selector) => {
+            const index = selector.nodes.findLastIndex(({ type }) => {
+              return type === "class" || type === "tag" || type === "id" || type === "universal";
+            });
+            if (index !== -1) {
+              const lastNode = selector.nodes[index];
+              lastNode.parent?.insertAfter(
+                lastNode,
+                selectorParser.attribute({
+                  attribute: `qk-${hash}`,
+                  value: void 0,
+                  raws: {}
+                })
+              );
+            }
+          });
+        }).processSync(rule.selector);
+      }
+    }
+  ]);
+  const ret = await processor.process(code, {
+    from: map.file,
+    map: {
+      prev: map,
+      annotation: false
+    }
+  });
+  return { code: ret.css, mappings: ret.map.toJSON().mappings };
+}
+
+function qingkuaiPlugin() {
+  let isDev;
+  let sourcemap;
+  let cssSourcemap;
+  let viteConfig;
+  const compileResultCache = /* @__PURE__ */ new Map();
+  const qingkuaiConfigurations = /* @__PURE__ */ new Map();
+  const qingkuaiPackageServeRE = /node_modules\/\.vite\/deps\/chunk.*$/;
+  const confIdentifierRE = /__qk_expose_(?:dependencies|destructions)__/g;
+  const styleIdRE = /^virtual:\[\d+\].*?\.qk.(?:css|s[ac]ss|less|stylus|postcss)\?\d{13}$/;
+  const qingkuaiPackageBuildRE = /node_modules\/qingkuai\/dist\/esm\/(?:chunks|runtime)\/\w+\.js$/;
+  return {
+    name: "qingkuai-compiler",
+    config(_, env) {
+      isDev = env.command === "serve";
+    },
+    configureServer(server) {
+      createQingkuaiConfigurationWatcher(server);
+    },
+    configResolved(config) {
+      viteConfig = config;
+      if (isDev) {
+        sourcemap = true;
+        cssSourcemap = !!config.css.devSourcemap;
+      } else {
+        cssSourcemap = true;
+        sourcemap = config.build.sourcemap !== false;
+      }
+      loadAllQingkuaiConfigurations(config.root);
+    },
+    resolveId(id, importer) {
+      if (styleIdRE.test(id)) {
+        return id;
+      }
+      if (importer?.endsWith(".qk") && !extname(id)) {
+        const qingkuaiConfig = getQingkuaiConfiguration(id);
+        return id + (qingkuaiConfig.resolveImportExtension ? ".qk" : "");
+      }
+    },
+    async load(id) {
+      if (styleIdRE.test(id)) {
+        const { fileId, index } = parseStyleId(id);
+        if (index === -1) {
+          return "";
+        }
+        let virtualFileName;
+        const compileRes = compileResultCache.get(fileId);
+        const style = compileRes.inputDescriptor.styles[index];
+        while (true) {
+          const hash = randomBytes(6).toString("hex");
+          virtualFileName = `${fileId}.${hash}.${style.lang}`;
+          if (!existsSync(virtualFileName)) {
+            break;
+          }
+        }
+        const preprocessRes = await preprocessCSS(style.code, virtualFileName, {
+          ...viteConfig,
+          css: {
+            ...viteConfig.css,
+            postcss: {
+              from: virtualFileName
+            }
+          }
+        });
+        if (!cssSourcemap) {
+          return preprocessRes.code;
+        }
+        const assertedPreprocessMap = preprocessRes.map;
+        const attachScopeResult = await attachScopeForStyleSelectors(
+          preprocessRes.code,
+          compileRes.hashId,
+          assertedPreprocessMap,
+          virtualFileName
+        );
+        const offsetMappings = encode(
+          offsetSourceMap(
+            attachScopeResult.mappings,
+            preprocessRes.deps?.size || 0,
+            style.loc.start.line - 1,
+            style.loc.start.column - 1
+          )
+        );
+        return {
+          code: attachScopeResult.code,
+          map: {
+            version: 3,
+            mappings: offsetMappings,
+            names: assertedPreprocessMap.names,
+            sources: [...assertedPreprocessMap.sources.slice(0, -1), fileId]
+          }
+        };
+      }
+    },
+    async transform(src, id) {
+      const qingkuaiConfig = getQingkuaiConfiguration(id);
+      if (!id.endsWith(".qk")) {
+        if (isDev && qingkuaiPackageServeRE.test(id) || !isDev && qingkuaiPackageBuildRE.test(id)) {
+          const ret = src.replace(confIdentifierRE, (s) => {
+            switch (s) {
+              case "__qk_expose_dependencies__":
+                return JSON.stringify(!!qingkuaiConfig.exposeDependencies);
+              case "__qk_expose_destructions__":
+                return JSON.stringify(!!qingkuaiConfig.exposeDestructions);
+              default:
+                return s;
+            }
+          });
+          return ret;
+        }
+        return;
+      }
+      const compileRes = compile(src, {
+        sourcemap,
+        debug: isDev,
+        hashId: compileResultCache.get(id)?.hashId || void 0,
+        reserveTemplateComment: getReserveHtmlComments(qingkuaiConfig),
+        componentName: util.kebab2Camel(basename(id, extname(id)), true)
+      });
+      compileRes.messages.forEach(({ type, value: warning }) => {
+        if (type === "warning") {
+          this.warn(warning.message);
+        }
+      });
+      compileResultCache.set(id, compileRes);
+      const compiledCodeArr = [compileRes.code];
+      compileRes.inputDescriptor.styles.forEach((_, index) => {
+        compiledCodeArr.push(`import "virtual:[${index}]${id}.css?${Date.now()}"`);
+      });
+      const baseMap = {
+        version: 3,
+        sources: [id],
+        sourcesContent: [src]
+      };
+      const compiledCode = compiledCodeArr.join("\n");
+      if (!compileRes.inputDescriptor.script.isTS) {
+        if (!sourcemap) {
+          return compiledCode;
+        }
+        return {
+          code: compiledCode,
+          map: Object.assign(baseMap, {
+            mappings: compileRes.mappings
+          })
+        };
+      }
+      const esBuildCompileRes = await transformWithEsbuild(
+        compiledCode,
+        id,
+        {
+          sourcemap,
+          loader: "ts",
+          target: "esnext"
+        },
+        sourcemap ? {
+          version: 3,
+          sources: [id],
+          sourcesContent: [src],
+          mappings: compileRes.mappings
+        } : void 0
+      );
+      if (!sourcemap) {
+        return esBuildCompileRes.code;
+      }
+      return {
+        code: esBuildCompileRes.code,
+        map: Object.assign(baseMap, {
+          mappings: esBuildCompileRes.map.mappings
+        })
+      };
+    }
+  };
+  function getQingkuaiConfiguration(id) {
+    let config = {
+      insertTipComments: true,
+      exposeDestructions: isDev,
+      exposeDependencies: isDev,
+      resolveImportExtension: true,
+      reserveHtmlComments: "development"
+    };
+    while (true) {
+      const dir = dirname(id);
+      if (dir === id) {
+        break;
+      }
+      const got = qingkuaiConfigurations.get(id = dir);
+      if (got) {
+        config = got;
+        break;
+      }
+    }
+    return config;
+  }
+  function getReserveHtmlComments(config) {
+    switch (config.reserveHtmlComments) {
+      case "all":
+        return true;
+      case "never":
+        return false;
+      case "production":
+        return !isDev;
+      default:
+        return isDev;
+    }
+  }
+  function createQingkuaiConfigurationWatcher(server) {
+    const watcher = server.watcher.add([".qingkuairc", "!**/node_modules/**"]);
+    watcher.on("unlink", (path) => qingkuaiConfigurations.delete(dirname(path)));
+    watcher.on("change", recordQingkuaiConfiguration);
+    watcher.on("add", recordQingkuaiConfiguration);
+  }
+  function loadAllQingkuaiConfigurations(workspaceDir) {
+    findFilesByName(workspaceDir, ".qingkuairc", /* @__PURE__ */ new Set(["node_modules"])).forEach((fileName) => {
+      recordQingkuaiConfiguration(fileName);
+    });
+  }
+  function recordQingkuaiConfiguration(fileName) {
+    try {
+      qingkuaiConfigurations.set(dirname(fileName), JSON.parse(readFileSync(fileName, "utf-8")));
+    } catch {
+    }
+  }
+}
+function parseStyleId(id) {
+  const m1 = /^virtual:\[(\d+)\]/.exec(id);
+  const m2 = /\.[a-z]+\?\d{13}$/.exec(id);
+  if (!m1 || !m2) {
+    return {
+      index: -1,
+      fileId: ""
+    };
+  }
+  return {
+    index: parseInt(m1[1]),
+    fileId: id.slice(m1.index + m1[0].length, m2.index)
+  };
+}
+
+export { qingkuaiPlugin as default };
+//# sourceMappingURL=index.js.map

package/dist/temp-type/index.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "vite";
+export default function qingkuaiPlugin(): Plugin;

package/dist/temp-type/scope.d.ts

@@ -0,0 +1,5 @@
+import type { SourceMap } from "./types";
+export declare function attachScopeForStyleSelectors(code: string, hash: string, map: SourceMap, sourceFile: string): Promise<{
+    code: string;
+    mappings: string;
+}>;

package/dist/temp-type/sourcemap.d.ts

@@ -0,0 +1,4 @@
+import type { SourceMap } from "./types";
+import type { SourceMapMappings } from "@jridgewell/sourcemap-codec";
+export declare function offsetSourceMap(mappings: string, sourceIndex: number, preLine: number, preColumn: number): SourceMapMappings;
+export declare function getSourceFile(sourcemap: SourceMap, line: number, column: number): string;

package/dist/temp-type/types.d.ts

@@ -0,0 +1,18 @@
+export interface SourceMap {
+    version: number;
+    file?: string;
+    names: string[];
+    mappings: string;
+    sources: string[];
+    sourceRoot?: string;
+    sourcesContent?: string[];
+    x_google_ignoreList?: number[];
+}
+export type QingkuaiConfiguration = Partial<{
+    exposeDestructions: boolean;
+    exposeDependencies: boolean;
+    insertTipComments: boolean;
+    resolveImportExtension: boolean;
+    convenientDerivedDeclaration: boolean;
+    reserveHtmlComments: "all" | "never" | "development" | "production";
+}>;

package/dist/temp-type/util.d.ts

@@ -0,0 +1 @@
+export declare function findFilesByName(dir: string, targetFileName: string, ignoreList: Set<string>): string[];

package/package.json

@@ -2,7 +2,7 @@
     "name": "vite-plugin-qingkuai",
     "author": "mlgq",
     "license": "MIT",
-    "version": "1.0.1",
+    "version": "1.0.3",
     "type": "module",
     "keywords": [
         "vite",
@@ -18,8 +18,8 @@
     },
     "scripts": {
         "dev": "rollup -c -w",
-        "build": "rimraf dist && rollup -c",
-        "postpublish": "curl -X PUT 'https://registry-direct.npmmirror.com/-/package/vite-plugin-qingkuai/sync'"
+        "build": "rimraf dist && tsc && rollup -c && rimraf dist/temp-types",
+        "postpublish": "curl -X PUT 'https://registry-direct.npmmirror.com/-/package/vite-plugin-qingkuai/syncs'"
     },
     "devDependencies": {
         "@types/fs-extra": "^11.0.4",
@@ -28,6 +28,7 @@
         "qingkuai": "^1.0.24",
         "rimraf": "^6.0.1",
         "rollup": "^4.38.0",
+        "rollup-plugin-dts": "^6.2.1",
         "rollup-plugin-esbuild": "^6.2.1",
         "vite": "^6.2.4"
     },

package/.prettierrc

@@ -1,7 +0,0 @@
-{
-    "tabWidth": 4,
-    "semi": false,
-    "printWidth": 120,
-    "arrowParens": "avoid",
-    "trailingComma": "none"
-}

package/rollup.config.js

@@ -1,44 +0,0 @@
-import * as rollup from "rollup"
-import esbuild from "rollup-plugin-esbuild"
-
-export default rollup.defineConfig(() => {
-    const inputOptions = {
-        external: [
-            "vite",
-            "postcss",
-            "node:fs",
-            "node:path",
-            "node:crypto",
-            "source-map-js",
-            "merge-source-map",
-            "qingkuai/compiler",
-            "@ampproject/remapping",
-            "postcss-selector-parser",
-            "@jridgewell/sourcemap-codec"
-        ],
-        input: {
-            index: "./src/index.ts"
-        },
-        output: {
-            dir: "dist",
-            format: "es",
-            sourcemap: true
-        },
-        plugins: [
-            esbuild({
-                target: "esNext"
-            })
-        ]
-    }
-
-    return [
-        inputOptions,
-        Object.assign({}, inputOptions, {
-            output: {
-                dir: "dist",
-                format: "cjs",
-                entryFileNames: "[name].cjs"
-            }
-        })
-    ]
-})

package/src/create-sourcemap-files.ts

@@ -1,24 +0,0 @@
-import type { SourceMap } from "./types"
-
-import fs from "fs-extra"
-import path from "node:path"
-
-export function generateSourceMapFiles(generate: string, map: SourceMap) {
-    const sourcemapPath = path.resolve(__dirname, "../sourcemap-test")
-    const gpath = path.resolve(sourcemapPath, "./g.css")
-    const mpath = path.resolve(sourcemapPath, "./s.css.map")
-    fs.removeSync(gpath)
-    fs.removeSync(mpath)
-    fs.writeFileSync(gpath, generate, "utf-8")
-    fs.writeFileSync(
-        mpath,
-        JSON.stringify({
-            version: 3,
-            names: map.names,
-            sources: map.sources,
-            mappings: map.mappings,
-            sourcesContent: map.sourcesContent
-        }),
-        "utf-8"
-    )
-}

package/src/index.ts

@@ -1,280 +0,0 @@
-import type { CompileResult } from "qingkuai/compiler"
-import type { QingkuaiConfiguration, SourceMap } from "./types"
-import type { Plugin, ResolvedConfig, ViteDevServer } from "vite"
-
-import { findFilesByName } from "./util"
-import { randomBytes } from "node:crypto"
-import { offsetSourceMap } from "./sourcemap"
-import { compile, util } from "qingkuai/compiler"
-import { existsSync, readFileSync } from "node:fs"
-import { encode } from "@jridgewell/sourcemap-codec"
-import { basename, dirname, extname } from "node:path"
-import { attachScopeForStyleSelectors } from "./scope"
-import { transformWithEsbuild, preprocessCSS } from "vite"
-
-export default function qingkuaiPlugin(): Plugin {
-    let isDev: boolean
-    let sourcemap: boolean
-    let cssSourcemap: boolean
-    let viteConfig: ResolvedConfig
-
-    const parseFailedConfigFiles: string[] = []
-    const compileResultCache = new Map<string, CompileResult>()
-    const qingkuaiConfigurations = new Map<string, QingkuaiConfiguration>()
-
-    const confIdentifierRE = /__qk_expose_(?:dependencies|destructions)__/g
-    const styleIdRE = /^virtual:\[\d+\].*?\.qk.(?:css|s[ac]ss|less|stylus|postcss)\?\d{13}$/
-    const qingkuaiPackageRE = /node_modules\/qingkuai\/dist\/esm\/(?:chunks|runtime)\/\w+\.js$/
-
-    return {
-        name: "qingkuai-compiler",
-
-        config(_, env) {
-            isDev = env.command === "serve"
-        },
-
-        configureServer(server) {
-            createQingkuaiConfigurationWatcher(server)
-        },
-
-        configResolved(config) {
-            viteConfig = config
-            if (isDev) {
-                sourcemap = true
-                cssSourcemap = !!config.css.devSourcemap
-            } else {
-                cssSourcemap = true
-                sourcemap = config.build.sourcemap !== false
-            }
-            loadAllQingkuaiConfigurations(config.root)
-        },
-
-        resolveId(id, importer) {
-            if (styleIdRE.test(id)) {
-                return id
-            }
-            if (importer?.endsWith(".qk") && !extname(id)) {
-                const qingkuaiConfig = getQingkuaiConfiguration(id)
-                return id + (qingkuaiConfig.resolveImportExtension ? ".qk" : "")
-            }
-        },
-
-        async load(id) {
-            if (styleIdRE.test(id)) {
-                const { fileId, index } = parseStyleId(id)
-                if (index === -1) {
-                    return ""
-                }
-
-                let virtualFileName: string
-                const compileRes = compileResultCache.get(fileId)!
-                const style = compileRes.inputDescriptor.styles[index]
-
-                // create a relative and not existing file name
-                while (true) {
-                    const hash = randomBytes(6).toString("hex")
-                    virtualFileName = `${fileId}.${hash}.${style.lang}`
-                    if (!existsSync(virtualFileName)) {
-                        break
-                    }
-                }
-
-                const preprocessRes = await preprocessCSS(style.code, virtualFileName, {
-                    ...viteConfig,
-                    css: {
-                        ...viteConfig.css,
-                        postcss: {
-                            from: virtualFileName
-                        }
-                    }
-                })
-                if (!cssSourcemap) {
-                    return preprocessRes.code
-                }
-
-                const assertedPreprocessMap = preprocessRes.map as SourceMap
-                const attachScopeResult = await attachScopeForStyleSelectors(
-                    preprocessRes.code,
-                    compileRes.hashId,
-                    assertedPreprocessMap,
-                    virtualFileName
-                )
-                const offsetMappings = encode(
-                    offsetSourceMap(
-                        attachScopeResult.mappings,
-                        preprocessRes.deps?.size || 0,
-                        style.loc.start.line - 1,
-                        style.loc.start.column - 1
-                    )
-                )
-                return {
-                    code: attachScopeResult.code,
-                    map: {
-                        version: 3,
-                        mappings: offsetMappings,
-                        names: assertedPreprocessMap.names,
-                        sources: [...assertedPreprocessMap.sources.slice(0, -1), fileId]
-                    }
-                }
-            }
-        },
-
-        async transform(src, id) {
-            const qingkuaiConfig = getQingkuaiConfiguration(id)
-            if (!id.endsWith(".qk")) {
-                if (!isDev && qingkuaiPackageRE.test(id)) {
-                    const ret = src.replace(confIdentifierRE, s => {
-                        switch (s) {
-                            case "__qk_expose_dependencies__":
-                                return JSON.stringify(!!qingkuaiConfig.exposeDependencies)
-                            case "__qk_expose_destructions__":
-                                return JSON.stringify(!!qingkuaiConfig.exposeDestructions)
-                            default:
-                                return s
-                        }
-                    })
-                    return ret
-                }
-                return
-            }
-
-            const compileRes = compile(src, {
-                sourcemap,
-                debug: isDev,
-                hashId: compileResultCache.get(id)?.hashId || undefined,
-                reserveTemplateComment: getReserveHtmlComments(qingkuaiConfig),
-                componentName: util.kebab2Camel(basename(id, extname(id)), true)
-            })
-            compileRes.messages.forEach(({ type, value: warning }) => {
-                if (type === "warning") {
-                    this.warn(warning.message)
-                }
-            })
-            compileResultCache.set(id, compileRes)
-
-            const compiledCodeArr = [compileRes.code]
-            compileRes.inputDescriptor.styles.forEach((_, index) => {
-                compiledCodeArr.push(`import "virtual:[${index}]${id}.css?${Date.now()}"`)
-            })
-
-            const baseMap: any = {
-                version: 3,
-                sources: [id],
-                sourcesContent: [src]
-            }
-            const compiledCode = compiledCodeArr.join("\n")
-            if (!compileRes.inputDescriptor.script.isTS) {
-                if (!sourcemap) {
-                    return compiledCode
-                }
-                return {
-                    code: compiledCode,
-                    map: Object.assign(baseMap, {
-                        mappings: compileRes.mappings
-                    })
-                }
-            }
-
-            const esBuildCompileRes = await transformWithEsbuild(
-                compiledCode,
-                id,
-                {
-                    sourcemap,
-                    loader: "ts",
-                    target: "esnext"
-                },
-                sourcemap
-                    ? {
-                          version: 3,
-                          sources: [id],
-                          sourcesContent: [src],
-                          mappings: compileRes.mappings
-                      }
-                    : undefined
-            )
-
-            if (!sourcemap) {
-                return esBuildCompileRes.code
-            }
-            return {
-                code: esBuildCompileRes.code,
-                map: Object.assign(baseMap, {
-                    mappings: esBuildCompileRes.map.mappings
-                })
-            }
-        }
-    }
-
-    function getQingkuaiConfiguration(id: string) {
-        let config: QingkuaiConfiguration = {
-            insertTipComments: true,
-            exposeDestructions: isDev,
-            exposeDependencies: isDev,
-            resolveImportExtension: true,
-            reserveHtmlComments: "development"
-        }
-        while (true) {
-            const dir = dirname(id)
-            if (dir === id) {
-                break
-            }
-
-            const got = qingkuaiConfigurations.get((id = dir))
-            if (got) {
-                config = got
-                break
-            }
-        }
-        return config
-    }
-
-    function getReserveHtmlComments(config: QingkuaiConfiguration) {
-        switch (config.reserveHtmlComments) {
-            case "all":
-                return true
-            case "never":
-                return false
-            case "production":
-                return !isDev
-            default:
-                return isDev
-        }
-    }
-
-    function createQingkuaiConfigurationWatcher(server: ViteDevServer) {
-        const watcher = server.watcher.add([".qingkuairc", "!**/node_modules/**"])
-        watcher.on("unlink", path => qingkuaiConfigurations.delete(dirname(path)))
-        watcher.on("change", recordQingkuaiConfiguration)
-        watcher.on("add", recordQingkuaiConfiguration)
-    }
-
-    function loadAllQingkuaiConfigurations(workspaceDir: string) {
-        findFilesByName(workspaceDir, ".qingkuairc", new Set(["node_modules"])).forEach(fileName => {
-            recordQingkuaiConfiguration(fileName)
-        })
-    }
-
-    function recordQingkuaiConfiguration(fileName: string) {
-        try {
-            qingkuaiConfigurations.set(dirname(fileName), JSON.parse(readFileSync(fileName, "utf-8")))
-        } catch {
-            parseFailedConfigFiles.push(fileName)
-        }
-    }
-}
-
-function parseStyleId(id: string) {
-    const m1 = /^virtual:\[(\d+)\]/.exec(id)!
-    const m2 = /\.[a-z]+\?\d{13}$/.exec(id)!
-    if (!m1 || !m2) {
-        return {
-            index: -1,
-            fileId: ""
-        }
-    }
-
-    return {
-        index: parseInt(m1[1]),
-        fileId: id.slice(m1.index + m1[0].length, m2.index)
-    }
-}

package/src/scope.ts

@@ -1,47 +0,0 @@
-import type { SourceMap } from "./types"
-
-import postcss from "postcss"
-import { getSourceFile } from "./sourcemap"
-import selectorParser from "postcss-selector-parser"
-
-export async function attachScopeForStyleSelectors(code: string, hash: string, map: SourceMap, sourceFile: string) {
-    const processor = postcss([
-        {
-            postcssPlugin: "postcss-attach-scope-qingkuai",
-            Rule(rule) {
-                const { line, column } = rule.source!.start!
-                if (getSourceFile(map, line, column) !== sourceFile) {
-                    return
-                }
-
-                rule.selector = selectorParser(selectors => {
-                    selectors.each(selector => {
-                        const index = selector.nodes.findLastIndex(({ type }) => {
-                            return type === "class" || type === "tag" || type === "id" || type === "universal"
-                        })
-                        if (index !== -1) {
-                            const lastNode = selector.nodes[index]!
-                            lastNode.parent?.insertAfter(
-                                lastNode,
-                                selectorParser.attribute({
-                                    attribute: `qk-${hash}`,
-                                    value: undefined,
-                                    raws: {}
-                                })
-                            )
-                        }
-                    })
-                }).processSync(rule.selector)
-            }
-        }
-    ])
-
-    const ret = await processor.process(code, {
-        from: map.file,
-        map: {
-            prev: map,
-            annotation: false
-        }
-    })
-    return { code: ret.css, mappings: ret.map.toJSON().mappings }
-}

package/src/sourcemap.ts

@@ -1,38 +0,0 @@
-import type { SourceMap } from "./types"
-import type { SourceMapMappings } from "@jridgewell/sourcemap-codec"
-
-import { SourceMapConsumer } from "source-map-js"
-import { decode } from "@jridgewell/sourcemap-codec"
-
-export function offsetSourceMap(
-    mappings: string,
-    sourceIndex: number,
-    preLine: number,
-    preColumn: number
-): SourceMapMappings {
-    return decode(mappings).map(line => {
-        return line.map(segment => {
-            if (segment.length === 1 || segment[1] !== sourceIndex) {
-                return segment
-            }
-            if (segment[2] === preLine) {
-                segment[3] += preColumn
-            } else {
-                segment[2] += preLine
-            }
-            return segment
-        })
-    })
-}
-
-export function getSourceFile(sourcemap: SourceMap, line: number, column: number) {
-    const consumer = new SourceMapConsumer({
-        ...sourcemap,
-        version: sourcemap.version.toString()
-    })
-
-    return consumer.originalPositionFor({
-        line: line,
-        column: column
-    }).source
-}

package/src/types.ts

@@ -1,19 +0,0 @@
-export interface SourceMap {
-    version: number
-    file?: string
-    names: string[]
-    mappings: string
-    sources: string[]
-    sourceRoot?: string
-    sourcesContent?: string[]
-    x_google_ignoreList?: number[]
-}
-
-export type QingkuaiConfiguration = Partial<{
-    exposeDestructions: boolean
-    exposeDependencies: boolean
-    insertTipComments: boolean
-    resolveImportExtension: boolean
-    convenientDerivedDeclaration: boolean
-    reserveHtmlComments: "all" | "never" | "development" | "production"
-}>

package/src/util.ts

@@ -1,21 +0,0 @@
-import { join } from "node:path"
-import { readdirSync } from "node:fs"
-
-export function findFilesByName(dir: string, targetFileName: string, ignoreList: Set<string>) {
-    const result: string[] = []
-    const entries = readdirSync(dir, { withFileTypes: true })
-
-    for (const entry of entries) {
-        if (ignoreList.has(entry.name)) {
-            continue
-        }
-
-        const fullPath = join(dir, entry.name)
-        if (entry.name === targetFileName) {
-            result.push(fullPath)
-        } else if (entry.isDirectory()) {
-            result.push(...findFilesByName(fullPath, targetFileName, ignoreList))
-        }
-    }
-    return result
-}

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-    "compilerOptions": {
-        "strict": true,
-        "noEmit": true,
-        "target": "ESNext",
-        "skipLibCheck": true,
-        "moduleResolution": "bundler"
-    }
-}