@fenglimg/fabric-shared 1.8.0-rc.3 → 2.0.0

package/dist/node.js

@@ -1,6 +1,175 @@
-import {
-  detectFramework
-} from "./chunk-GI6L6VTT.js";
+// src/detector.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function detectFramework(root) {
+  const evidence = [];
+  const creatorConfigPath = join(root, "project.config.json");
+  if (existsSync(creatorConfigPath)) {
+    const version = readCreatorVersion(creatorConfigPath);
+    return {
+      kind: "cocos-creator",
+      version,
+      subkind: inferCocosSubkind(root, version),
+      evidence: version === "unknown" ? ["project.config.json"] : [`project.config.json: creator.version=${version}`],
+      framework: "cocos-creator",
+      confidence: "HIGH",
+      ast_evidence: [],
+      co_packages: collectProjectFileEvidence(root, ["package.json", "tsconfig.json"])
+    };
+  }
+  const packageJsonPath = join(root, "package.json");
+  if (existsSync(packageJsonPath)) {
+    const packageJson = readPackageJson(packageJsonPath);
+    const creatorVersion = packageJson.creator?.version;
+    if (typeof creatorVersion === "string" && creatorVersion.trim().length > 0) {
+      const deps2 = collectDependencyVersions(packageJson);
+      return {
+        kind: "cocos-creator",
+        version: creatorVersion,
+        subkind: inferCocosSubkind(root, creatorVersion),
+        evidence: [`package.json: creator.version=${creatorVersion}`],
+        framework: "cocos-creator",
+        confidence: "HIGH",
+        ast_evidence: [],
+        co_packages: collectCoPackages(deps2, "cocos-creator", root)
+      };
+    }
+    const deps = collectDependencyVersions(packageJson);
+    for (const [dependencyName, kind] of [
+      ["next", "next"],
+      ["vite", "vite"],
+      ["react", "react"],
+      ["vue", "vue"]
+    ]) {
+      if (deps.has(dependencyName)) {
+        const version = deps.get(dependencyName) ?? "unknown";
+        evidence.push(`package.json dependency: ${dependencyName}@${version}`);
+        return {
+          kind,
+          version,
+          subkind: inferPackageSubkind(kind),
+          evidence,
+          framework: kind,
+          confidence: determinePackageConfidence(kind, deps, root),
+          ast_evidence: [],
+          co_packages: collectCoPackages(deps, kind, root)
+        };
+      }
+    }
+    evidence.push("package.json");
+  }
+  if (existsSync(join(root, "Cargo.toml"))) {
+    return {
+      kind: "rust",
+      version: "unknown",
+      subkind: "cargo-project",
+      evidence: ["Cargo.toml"],
+      framework: "rust",
+      confidence: "HIGH",
+      ast_evidence: [],
+      co_packages: collectProjectFileEvidence(root, ["Cargo.lock"])
+    };
+  }
+  if (existsSync(join(root, "pyproject.toml"))) {
+    return {
+      kind: "python",
+      version: "unknown",
+      subkind: "pyproject",
+      evidence: ["pyproject.toml"],
+      framework: "python",
+      confidence: "HIGH",
+      ast_evidence: [],
+      co_packages: collectProjectFileEvidence(root, ["uv.lock", "poetry.lock", "requirements.txt"])
+    };
+  }
+  return {
+    kind: "unknown",
+    version: "unknown",
+    subkind: "unknown",
+    evidence,
+    framework: "unknown",
+    confidence: "LOW",
+    ast_evidence: [],
+    co_packages: []
+  };
+}
+function readPackageJson(packageJsonPath) {
+  try {
+    return JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function readCreatorVersion(creatorConfigPath) {
+  try {
+    const creatorConfig = JSON.parse(readFileSync(creatorConfigPath, "utf8"));
+    return creatorConfig.creator?.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function collectDependencyVersions(packageJson) {
+  return new Map([
+    ...Object.entries(packageJson.dependencies ?? {}),
+    ...Object.entries(packageJson.devDependencies ?? {}),
+    ...Object.entries(packageJson.peerDependencies ?? {}),
+    ...Object.entries(packageJson.optionalDependencies ?? {})
+  ]);
+}
+function inferCocosSubkind(root, version) {
+  const majorVersion = Number.parseInt(version.split(".")[0] ?? "", 10);
+  if (majorVersion === 2) {
+    return "javascript-traditional";
+  }
+  if (majorVersion >= 3) {
+    return "typescript-component";
+  }
+  return existsSync(join(root, "tsconfig.json")) ? "typescript-component" : "javascript-traditional";
+}
+function inferPackageSubkind(kind) {
+  switch (kind) {
+    case "next":
+      return "next-application";
+    case "vite":
+      return "vite-application";
+    case "react":
+      return "react-application";
+    case "vue":
+      return "vue-application";
+    default:
+      return "unknown";
+  }
+}
+function determinePackageConfidence(kind, deps, root) {
+  const coPackages = collectCoPackages(deps, kind, root);
+  return coPackages.length > 0 ? "HIGH" : "MEDIUM";
+}
+function collectCoPackages(deps, kind, root) {
+  const expectedPackagesByFramework = {
+    next: ["react", "react-dom", "typescript"],
+    vite: ["@vitejs/plugin-react", "@vitejs/plugin-vue", "typescript", "react", "vue"],
+    react: ["react-dom", "@types/react", "@types/react-dom"],
+    vue: ["@vitejs/plugin-vue", "typescript"],
+    "cocos-creator": ["typescript"]
+  };
+  const expectedProjectFilesByFramework = {
+    next: ["next.config.js", "next.config.mjs", "next.config.ts", "tsconfig.json"],
+    vite: ["vite.config.js", "vite.config.mjs", "vite.config.ts", "tsconfig.json"],
+    react: ["tsconfig.json"],
+    vue: ["vue.config.js", "vite.config.ts", "tsconfig.json"],
+    "cocos-creator": ["project.config.json", "tsconfig.json"]
+  };
+  return [
+    ...compactStrings((expectedPackagesByFramework[kind] ?? []).map((packageName) => deps.has(packageName) ? packageName : null)),
+    ...collectProjectFileEvidence(root, expectedProjectFilesByFramework[kind] ?? [])
+  ];
+}
+function collectProjectFileEvidence(root, relativePaths) {
+  return relativePaths.filter((relativePath) => existsSync(join(root, relativePath)));
+}
+function compactStrings(values) {
+  return [...new Set(values.filter((value) => value !== null && value !== void 0 && value.length > 0))];
+}
 export {
   detectFramework
 };