@dimina-kit/compiler 0.0.2-dev.20260718143821 → 0.0.2-dev.20260728065133

package/dist/stage-worker.node.js

@@ -3,12 +3,12 @@ import {
   preloadStage,
   resetCompilerState,
   runStage
-} from "./pool.node-chunks/chunk-LKL7FBHG.js";
+} from "./pool.node-chunks/chunk-WX4462A5.js";
 import {
   getAppId,
   getAppName,
   resetStoreInfo
-} from "./pool.node-chunks/chunk-7F3E2G42.js";
+} from "./pool.node-chunks/chunk-CKQISGZS.js";
 
 // src/stage-worker-node.js
 import { createRequire } from "node:module";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dimina-kit/compiler",
-  "version": "0.0.2-dev.20260718143821",
+  "version": "0.0.2-dev.20260728065133",
   "description": "dmcc compiler bundles (browser + node) that drive @dimina/compiler against a caller-injected node:fs replacement (no bundled fs)",
   "license": "MIT",
   "type": "module",
@@ -33,7 +33,7 @@
   ],
   "dependencies": {
     "@babel/parser": "^7.29.7",
-    "@vue/compiler-sfc": "^3.5.39",
+    "@vue/compiler-sfc": "^3.5.40",
     "assert": "^2.1.0",
     "autoprefixer": "^10.5.3",
     "buffer": "^6.0.3",
@@ -43,21 +43,21 @@
     "estree-walker": "^3.0.3",
     "events": "^3.3.0",
     "htmlparser2": "^12.0.0",
-    "less": "^4.6.7",
+    "less": "^4.8.1",
     "magic-string": "^0.30.21",
     "memfs": "^4.57.8",
-    "oxc-parser": "^0.139.0",
+    "oxc-parser": "^0.140.0",
     "oxc-walker": "^1.0.0",
     "path-browserify": "^1.0.1",
-    "postcss": "^8.5.19",
+    "postcss": "^8.5.23",
     "postcss-selector-parser": "^7.1.4",
-    "sass": "^1.101.0",
+    "sass": "^1.102.0",
     "source-map-js": "^1.2.1",
     "stream-browserify": "^3.0.0",
     "util": "^0.12.5"
   },
   "peerDependencies": {
-    "@oxc-parser/binding-wasm32-wasi": "^0.139.0",
+    "@oxc-parser/binding-wasm32-wasi": "^0.140.0",
     "esbuild-wasm": "^0.28.1"
   },
   "peerDependenciesMeta": {
@@ -72,6 +72,7 @@
     "esbuild-wasm": "^0.28.1"
   },
   "scripts": {
+    "check:wasm-alignment": "node scripts/check-wasm-alignment.js",
     "build:node": "node scripts/build-compiler.js node",
     "build:browser": "node scripts/build-compiler.js browser",
     "build": "pnpm run build:node && pnpm run build:browser",

package/scripts/check-wasm-alignment.js

@@ -0,0 +1,173 @@
+import { access, readFile } from 'node:fs/promises'
+import { fileURLToPath } from 'node:url'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+
+function printUsage() {
+  console.log(
+    'Usage: node scripts/check-wasm-alignment.js\n\n' +
+      'Fails if packages/compiler and upstream @dimina/compiler (dimina submodule,\n' +
+      'dimina/fe/packages/compiler) resolve any shared dependency — or the wasm/native\n' +
+      'build pairs oxc-parser/@oxc-parser/binding-wasm32-wasi and esbuild/esbuild-wasm —\n' +
+      'to a different installed version. Requires both workspaces to be installed\n' +
+      '(pnpm install, pnpm -C dimina/fe install).',
+  )
+}
+
+if (process.argv.includes('--help') || process.argv.includes('-h')) {
+  printUsage()
+  process.exit(0)
+}
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const root = path.resolve(__dirname, '..')
+const kitPkgPath = path.join(root, 'package.json')
+const diminaFeRoot = path.resolve(root, '../../dimina/fe')
+const upstreamPkgPath = path.join(diminaFeRoot, 'packages/compiler/package.json')
+
+async function readJson(p) {
+  return JSON.parse(await readFile(p, 'utf8'))
+}
+
+async function exists(p) {
+  try {
+    await access(p)
+    return true
+  } catch {
+    return false
+  }
+}
+
+// package.json only records the declared semver *range* (e.g. "^3.5.39");
+// for a dep whose major is >=1 that range also matches later minors
+// installed independently on each side. Walk the actual node_modules
+// resolution each side's own package.json would use, and climb to the
+// nearest package.json whose name matches (not just the first package.json
+// found, which could belong to a nested dependency).
+//
+// requiredPrefix guards the upstream (dimina/fe) side specifically: dimina/fe
+// is nested inside this repo, so if its own node_modules isn't installed,
+// Node's resolution walks up past it and can silently land in kit's own
+// hoisted node_modules — "resolved" would then just be comparing kit against
+// itself and reporting false alignment. Reject any resolution that doesn't
+// land under dimina/fe instead of treating it as a valid answer.
+async function resolveInstalledVersion(anchorPackageJsonPath, depName, requiredPrefix) {
+  let entry
+  try {
+    entry = createRequire(anchorPackageJsonPath).resolve(depName)
+  } catch {
+    return null
+  }
+  if (requiredPrefix && !entry.startsWith(requiredPrefix + path.sep)) {
+    return null
+  }
+  let dir = path.dirname(entry)
+  for (let hop = 0; hop < 16; hop++) {
+    const candidate = path.join(dir, 'package.json')
+    if (await exists(candidate)) {
+      const pkg = await readJson(candidate)
+      if (pkg.name === depName) return pkg.version
+    }
+    const parent = path.dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return null
+}
+
+// This package's node/browser bundles are esbuild-driven mirrors of
+// @dimina/compiler (upstream, in the dimina submodule) — same compiler
+// logic against a caller-injected fs. Compare live, not a hardcoded dep
+// list, so a newly-shared dependency is picked up automatically.
+const kitPkg = await readJson(kitPkgPath)
+let upstreamPkg
+try {
+  upstreamPkg = await readJson(upstreamPkgPath)
+} catch (err) {
+  console.error(
+    `check-wasm-alignment: could not read upstream package.json at ${upstreamPkgPath} (${err.message})\n` +
+      'The dimina submodule looks uninitialized. Run: git submodule update --init dimina',
+  )
+  process.exit(2)
+}
+
+// Scoped to deps kit itself declares. Packages dmcc source imports but kit
+// doesn't declare (e.g. @vue/shared, pulled in only via compatibility.js)
+// aren't independently resolved by kit at all — kit's esbuild config bundles
+// (inlines) anything not in its NODE_EXTERNAL list straight from the dimina/fe
+// source file that imports it, so that code is always upstream's current
+// install by construction. Drift is only possible for deps kit resolves on
+// its own — i.e. the ones it declares here.
+const kitDeps = { ...kitPkg.dependencies, ...kitPkg.devDependencies }
+const upstreamDeps = { ...upstreamPkg.dependencies }
+
+const mismatches = []
+const unresolved = []
+
+// Every shared dep here is part of dmcc's actual compile pipeline (e.g.
+// @vue/compiler-sfc's compileStyle/compileTemplate drive CSS scope-hash and
+// template codegen — not a cosmetic tool), so all of them get the same
+// resolved-version check as the wasm toolchain, not just oxc-parser/esbuild.
+// dimina/fe doesn't commit a lockfile (gitignored upstream), so its resolved
+// version can drift from kit's pinned lockfile purely from the passage of
+// time — that drift is exactly what this check exists to catch, not noise
+// to suppress by only comparing the declared specifier string.
+for (const name of Object.keys(kitDeps)) {
+  if (!(name in upstreamDeps)) continue
+
+  const kitVersion = await resolveInstalledVersion(kitPkgPath, name)
+  const upstreamVersion = await resolveInstalledVersion(upstreamPkgPath, name, diminaFeRoot)
+  if (!kitVersion || !upstreamVersion) {
+    unresolved.push(`  ${name}: kit=${kitVersion ?? 'unresolved'} upstream=${upstreamVersion ?? 'unresolved'}`)
+    continue
+  }
+  if (kitVersion !== upstreamVersion) {
+    mismatches.push(`  ${name}: kit resolves ${kitVersion}, upstream(@dimina/compiler) resolves ${upstreamVersion}`)
+  }
+}
+
+// The wasm builds of oxc-parser/esbuild are peer/dev deps here (native
+// bindings aren't available in the browser); their version must track the
+// non-wasm package they're a build target of, or the browser bundle can
+// silently run a different parser/bundler version than the node bundle.
+// Both sides of this pair live in kit's own package.json/node_modules, so
+// resolution never depends on dimina/fe being installed.
+const wasmPairs = [
+  ['oxc-parser', '@oxc-parser/binding-wasm32-wasi'],
+  ['esbuild', 'esbuild-wasm'],
+]
+
+for (const [nativeName, wasmName] of wasmPairs) {
+  const nativeVersion = await resolveInstalledVersion(kitPkgPath, nativeName)
+  const wasmVersion = await resolveInstalledVersion(kitPkgPath, wasmName)
+  if (!nativeVersion || !wasmVersion) {
+    unresolved.push(`  ${wasmName}/${nativeName}: kit=${nativeVersion ?? 'unresolved'}/${wasmVersion ?? 'unresolved'}`)
+    continue
+  }
+  if (nativeVersion !== wasmVersion) {
+    mismatches.push(`  ${wasmName} resolves ${wasmVersion}, does not match ${nativeName} resolving ${nativeVersion}`)
+  }
+}
+
+if (unresolved.length > 0) {
+  console.error(
+    'check-wasm-alignment: could not resolve installed versions for some shared deps — ' +
+      'this proves nothing either way, so treat it as a setup failure, not a pass:\n' +
+      unresolved.join('\n') +
+      '\nRun: pnpm install && pnpm -C dimina/fe install',
+  )
+  process.exit(2)
+}
+
+if (mismatches.length > 0) {
+  console.error(
+    'check-wasm-alignment: drift between packages/compiler and upstream @dimina/compiler ' +
+      '(dimina submodule) — this package re-implements dmcc against the same toolchain:\n' +
+      mismatches.join('\n') +
+      '\nRealign the drifted side (bump/pin in package.json, then pnpm install) and rebuild ' +
+      '(pnpm --filter @dimina-kit/compiler build).',
+  )
+  process.exit(1)
+}
+
+console.log('check-wasm-alignment: packages/compiler deps aligned with upstream @dimina/compiler')

package/dist/compile-core.node-chunks/chunk-2VRS523Z.js

@@ -1,8 +0,0 @@
-// src/shims/worker_threads.js
-var isMainThread = true;
-var parentPort = null;
-
-export {
-  isMainThread,
-  parentPort
-};

package/dist/compile-core.node-chunks/style-compiler-YWVITCJW.js

@@ -1,288 +0,0 @@
-import {
-  isMainThread,
-  parentPort
-} from "./chunk-2VRS523Z.js";
-import {
-  collectAssets,
-  fs_default,
-  getAppId,
-  getComponent,
-  getContentByPath,
-  getStyleExts,
-  getTargetPath,
-  getWorkPath,
-  resetStoreInfo,
-  tagWhiteList,
-  transformRpx
-} from "./chunk-QVEZ34FP.js";
-
-// ../../dimina/fe/packages/compiler/src/core/style-compiler.js
-import path from "node:path";
-import { compileStyle } from "@vue/compiler-sfc";
-import autoprefixer from "autoprefixer";
-import cssnano from "cssnano";
-import less from "less";
-import postcss from "postcss";
-import selectorParser from "postcss-selector-parser";
-import * as sass from "sass";
-var compileRes = /* @__PURE__ */ new Map();
-if (!isMainThread) {
-  parentPort.on("message", async ({ pages, storeInfo }) => {
-    try {
-      resetStoreInfo(storeInfo);
-      const progress = {
-        _completedTasks: 0,
-        get completedTasks() {
-          return this._completedTasks;
-        },
-        set completedTasks(value) {
-          this._completedTasks = value;
-          parentPort.postMessage({ completedTasks: this._completedTasks });
-        }
-      };
-      await compileSS(pages.mainPages, null, progress);
-      for (const [root, subPages] of Object.entries(pages.subPages)) {
-        await compileSS(subPages.info, root, progress);
-      }
-      compileRes.clear();
-      parentPort.postMessage({ success: true });
-    } catch (error) {
-      compileRes.clear();
-      parentPort.postMessage({
-        success: false,
-        error: {
-          message: error.message,
-          stack: error.stack,
-          name: error.name
-        }
-      });
-    }
-  });
-}
-async function compileSS(pages, root, progress) {
-  for (const page of pages) {
-    const code = await buildCompileCss(page, /* @__PURE__ */ new Set()) || "";
-    const filename = `${page.path.replace(/\//g, "_")}`;
-    if (root) {
-      const subDir = `${getTargetPath()}/${root}`;
-      if (!fs_default.existsSync(subDir)) {
-        fs_default.mkdirSync(subDir, { recursive: true });
-      }
-      fs_default.writeFileSync(`${subDir}/${filename}.css`, code);
-    } else {
-      const mainDir = `${getTargetPath()}/main`;
-      if (!fs_default.existsSync(mainDir)) {
-        fs_default.mkdirSync(mainDir, { recursive: true });
-      }
-      fs_default.writeFileSync(`${mainDir}/${filename}.css`, code);
-    }
-    progress.completedTasks++;
-  }
-}
-async function buildCompileCss(module, compiledPaths = /* @__PURE__ */ new Set()) {
-  let result = "";
-  const pendingModules = [module];
-  while (pendingModules.length > 0) {
-    const currentModule = pendingModules.pop();
-    const currentPath = currentModule.path || currentModule.absolutePath;
-    if (compiledPaths.has(currentPath)) {
-      continue;
-    }
-    compiledPaths.add(currentPath);
-    result += await enhanceCSS(currentModule) || "";
-    const componentPaths = Object.values(currentModule.usingComponents || {});
-    for (let index = componentPaths.length - 1; index >= 0; index--) {
-      const componentModule = getComponent(componentPaths[index]);
-      if (componentModule) {
-        pendingModules.push(componentModule);
-      }
-    }
-  }
-  return result;
-}
-function boostExternalClassSelectors(cssCode, moduleId) {
-  if (!moduleId || !cssCode) {
-    return cssCode;
-  }
-  const scopeAttribute = `data-v-${moduleId}`;
-  const externalScopeAttribute = "data-dd-external-class-scope";
-  const ast = postcss.parse(cssCode);
-  ast.walkRules((rule) => {
-    if (!rule.selector.includes(`[${scopeAttribute}]`)) {
-      return;
-    }
-    rule.selector = selectorParser((selectors) => {
-      for (const selector of [...selectors.nodes]) {
-        const boostedSelector = selector.clone();
-        const scopeNodes = [];
-        boostedSelector.walkAttributes((attribute) => {
-          if (attribute.attribute === scopeAttribute) {
-            scopeNodes.push(attribute);
-          }
-        });
-        const targetScope = scopeNodes.at(-1);
-        if (!targetScope) {
-          continue;
-        }
-        targetScope.parent.insertAfter(targetScope, selectorParser.attribute({
-          attribute: externalScopeAttribute,
-          operator: "~=",
-          quoteMark: '"',
-          value: scopeAttribute
-        }));
-        selectors.append(boostedSelector);
-      }
-    }).processSync(rule.selector);
-  });
-  return ast.toResult().css;
-}
-async function enhanceCSS(module) {
-  const absolutePath = module.absolutePath ? module.absolutePath : getAbsolutePath(module.path);
-  if (!absolutePath) {
-    return "";
-  }
-  const cacheKey = `${absolutePath}::${module.id || ""}`;
-  const inputCSS = getContentByPath(absolutePath);
-  if (!inputCSS) {
-    return "";
-  }
-  if (compileRes.has(cacheKey)) {
-    return compileRes.get(cacheKey);
-  }
-  let processedCSS = normalizeRootStyleImports(inputCSS);
-  const ext = path.extname(absolutePath).toLowerCase();
-  try {
-    if (ext === ".less") {
-      const result2 = await less.render(processedCSS, {
-        filename: absolutePath,
-        paths: [path.dirname(absolutePath), getWorkPath()]
-      });
-      processedCSS = result2.css;
-    } else if (ext === ".scss" || ext === ".sass") {
-      const result2 = sass.compileString(processedCSS, {
-        loadPaths: [path.dirname(absolutePath), getWorkPath()],
-        syntax: ext === ".sass" ? "indented" : "scss"
-      });
-      processedCSS = result2.css;
-    }
-  } catch (error) {
-    console.error(`[style] \u9884\u5904\u7406\u5668\u7F16\u8BD1\u5931\u8D25 ${absolutePath}:`, error.message);
-    processedCSS = inputCSS;
-  }
-  const fixedCSS = ensureImportSemicolons(processedCSS);
-  let ast;
-  try {
-    ast = postcss.parse(fixedCSS);
-  } catch (error) {
-    console.error(`[style] PostCSS \u89E3\u6790\u5931\u8D25 ${absolutePath}:`, error.message);
-    return "";
-  }
-  const promises = [];
-  ast.walk(async (node) => {
-    if (node.type === "atrule" && node.name === "import") {
-      const str = node.params.replace(/^['"]|['"]$/g, "");
-      const importFullPath = resolveStyleImportPath(absolutePath, str);
-      node.remove();
-      promises.push(buildCompileCss({ absolutePath: importFullPath, id: module.id }, /* @__PURE__ */ new Set()));
-    } else if (node.type === "rule") {
-      if (node.selector.includes("::v-deep")) {
-        node.selector = node.selector.replace(/::v-deep\s+(\S[^{]*)/g, ":deep($1)");
-      }
-      if (node.selector.includes(":host")) {
-        node.selector = processHostSelector(node.selector, module.id);
-      }
-      node.selector = selectorParser((selectors) => {
-        selectors.walkTags((tag) => {
-          if (tagWhiteList.includes(tag.value)) {
-            tag.value = `.dd-${tag.value}`;
-          }
-        });
-      }).processSync(node.selector);
-    } else if (node.type === "comment") {
-      node.remove();
-    }
-  });
-  ast.walkDecls((decl) => {
-    decl.value = normalizeCssUrlValue(decl.value, absolutePath);
-    decl.value = transformRpx(decl.value);
-  });
-  const cssCode = ast.toResult().css;
-  const moduleId = module.id;
-  const scopedCode = compileStyle({
-    source: cssCode,
-    id: moduleId,
-    scoped: !!moduleId
-  }).code;
-  const externalClassCode = boostExternalClassSelectors(scopedCode, moduleId);
-  const res = await postcss([
-    autoprefixer({ overrideBrowserslist: ["cover 99.5%"] }),
-    cssnano()
-  ]).process(externalClassCode, { from: void 0 });
-  const importCss = (await Promise.all(promises)).filter(Boolean).join("");
-  const result = importCss + res.css;
-  compileRes.set(cacheKey, result);
-  return result;
-}
-function normalizeCssUrlValue(value, absolutePath) {
-  return value.replace(/url\(([^)]+)\)/g, (fullMatch, rawUrl) => {
-    const cleanedUrl = rawUrl.trim().replace(/^['"]|['"]$/g, "");
-    if (!cleanedUrl || cleanedUrl.startsWith("data:image")) {
-      return fullMatch;
-    }
-    if (cleanedUrl.startsWith("//")) {
-      return `url(https:${cleanedUrl})`;
-    }
-    if (/^(https?:|blob:|data:)/.test(cleanedUrl)) {
-      return fullMatch;
-    }
-    const realSrc = collectAssets(getWorkPath(), absolutePath, cleanedUrl, getTargetPath(), getAppId());
-    return `url(${realSrc})`;
-  });
-}
-function getAbsolutePath(modulePath) {
-  const workPath = getWorkPath();
-  const src = modulePath.startsWith("/") ? modulePath : `/${modulePath}`;
-  for (const ssType of getStyleExts()) {
-    const ssFullPath = `${workPath}${src}${ssType}`;
-    if (fs_default.existsSync(ssFullPath)) {
-      return ssFullPath;
-    }
-    const indexSsFullPath = `${workPath}${src}/index${ssType}`;
-    if (fs_default.existsSync(indexSsFullPath)) {
-      return indexSsFullPath;
-    }
-  }
-}
-function resolveStyleImportPath(absolutePath, importPath, workPath = getWorkPath()) {
-  if (importPath.startsWith("/")) {
-    return path.join(workPath, importPath);
-  }
-  return path.resolve(path.dirname(absolutePath), importPath);
-}
-function normalizeRootStyleImports(source, workPath = getWorkPath()) {
-  return source.replace(/(@import\s+(?:\(.*?\)\s*)?(?:url\()?['"])(\/[^'")]+)(['"]\)?)/g, (_, prefix, importPath, suffix) => {
-    return `${prefix}${path.join(workPath, importPath)}${suffix}`;
-  });
-}
-function ensureImportSemicolons(css) {
-  return css.replace(/@import[^;\n]*$/gm, (match) => {
-    return match.endsWith(";") ? match : `${match};`;
-  });
-}
-function processHostSelector(selector, moduleId) {
-  const hostSelector = `[data-dd-style-host~="${moduleId}"]`;
-  return selector.replace(/:host\(([^)]+)\)/g, `${hostSelector}$1`).replace(/:host(?![\w-])/g, hostSelector);
-}
-function __resetStyleState() {
-  compileRes.clear();
-}
-export {
-  __resetStyleState,
-  boostExternalClassSelectors,
-  compileSS,
-  ensureImportSemicolons,
-  normalizeCssUrlValue,
-  normalizeRootStyleImports,
-  processHostSelector,
-  resolveStyleImportPath
-};

package/dist/pool.node-chunks/chunk-KLXXOLDF.js

@@ -1,8 +0,0 @@
-// src/shims/worker_threads.js
-var isMainThread = true;
-var parentPort = null;
-
-export {
-  isMainThread,
-  parentPort
-};