@batijs/core 0.0.3

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { ASTNode, ProxifiedModule } from 'magicast';
+export { generateCode, loadFile, parseModule } from 'magicast';
+export { addVitePlugin } from 'magicast/helpers';
+
+declare const features: readonly ["framework:solid", "auth:authjs", "rpc:telefunc", "server:hattip", "server:express"];
+declare const flags: Map<string | undefined, "framework:solid" | "auth:authjs" | "rpc:telefunc" | "server:hattip" | "server:express">;
+
+type MaybeContentGetter = (() => string | Promise<string>) | undefined;
+interface VikeMeta {
+    VIKE_MODULES?: (typeof features)[number][];
+}
+
+declare function transformAndGenerate(tree: ASTNode, meta: VikeMeta): Promise<string>;
+
+declare function loadAsJson(getter: MaybeContentGetter): Promise<any>;
+declare function loadAsMagicast<Exports extends object>(getter: MaybeContentGetter): Promise<ProxifiedModule<Exports>>;
+declare function loadRelativeFileAsMagicast<Exports extends object>(relativePath: string, meta: Pick<ImportMeta, "url">): Promise<ProxifiedModule<Exports>>;
+
+interface PackageJsonDeps {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+}
+declare function addDependency<T extends PackageJsonDeps, U extends PackageJsonDeps>(packageJson: T, scopedPackageJson: U, keys: {
+    devDependencies?: (keyof U["dependencies"] | keyof U["devDependencies"])[];
+    dependencies?: (keyof U["dependencies"] | keyof U["devDependencies"])[];
+}): T;
+
+export { MaybeContentGetter, PackageJsonDeps, VikeMeta, addDependency, features, flags, loadAsJson, loadAsMagicast, loadRelativeFileAsMagicast, transformAndGenerate };

package/dist/index.js

@@ -0,0 +1,180 @@
+// src/features.ts
+var features = [
+  "framework:solid",
+  // "framework:react", "framework:vue",
+  // "db:edgedb", "db:prisma",
+  "auth:authjs",
+  // "error:logrocket", "error:sentry",
+  "rpc:telefunc",
+  // "rpc:trpc",
+  "server:hattip",
+  "server:express"
+  // "clientRouting", "prerendering",
+];
+var flags = new Map(features.map((f) => [f.split(":").at(-1), f]));
+
+// src/parse.ts
+import { namedTypes, visit } from "ast-types";
+import { generateCode } from "magicast";
+
+// src/cleanup.ts
+import { ESLint } from "eslint";
+var eslint = new ESLint({
+  useEslintrc: false,
+  fix: true,
+  overrideConfig: {
+    parser: "@typescript-eslint/parser",
+    plugins: ["@typescript-eslint", "unused-imports"],
+    rules: {
+      "unused-imports/no-unused-imports": "error"
+    }
+  }
+});
+
+// src/parse.ts
+function evalCondition(code, meta = {}) {
+  code = code.replaceAll("import.meta", "VIKE_META");
+  code = `var VIKE_META = ${JSON.stringify(meta)};(${code})`;
+  return (0, eval)(code);
+}
+function transformAst(tree, meta) {
+  visit(tree, {
+    visitIdentifier(path) {
+      if (path.value.name === "VIKE_REMOVE") {
+        if (!path.parent) {
+          throw new Error("VIKE_REMOVE cannot appear at top level");
+        }
+        if (!namedTypes.ArrayExpression.check(path.parent?.parent?.value)) {
+          throw new Error("VIKE_REMOVE can only be an array element for now");
+        }
+        path.parent.prune();
+        this.traverse(path);
+        return;
+      }
+      this.traverse(path);
+    },
+    visitConditionalExpression(path) {
+      this.visitIfStatement(path);
+    },
+    visitIfStatement(path) {
+      let found = false;
+      this.traverse(path.get("test"), {
+        visitMemberExpression(path2) {
+          if (generateCode(path2.value).code.startsWith("import.meta.VIKE_")) {
+            found = true;
+          }
+          this.traverse(path2);
+        }
+      });
+      this.traverse(path);
+      if (!found)
+        return;
+      if (!evalCondition(generateCode(path.value.test).code, meta)) {
+        if (path.value.alternate) {
+          if (namedTypes.BlockStatement.check(path.value.alternate)) {
+            path.replace(...path.value.alternate.body);
+          } else {
+            path.replace(path.value.alternate);
+          }
+        } else {
+          path.prune();
+        }
+      } else {
+        if (namedTypes.BlockStatement.check(path.value.consequent)) {
+          path.replace(...path.value.consequent.body);
+        } else {
+          path.replace(path.value.consequent);
+        }
+      }
+    }
+  });
+  return tree;
+}
+async function transformAndGenerate(tree, meta) {
+  const ast = transformAst(tree, meta);
+  const code = generateCode(ast).code;
+  const linted = await eslint.lintText(code);
+  return linted[0].output ?? code;
+}
+
+// src/loaders.ts
+import { loadFile, parseModule } from "magicast";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+// src/assert.ts
+function assert(condition, message) {
+  if (condition) {
+    return;
+  }
+  throw new Error(message);
+}
+
+// src/loaders.ts
+async function loadAsJson(getter) {
+  const content = await getter?.();
+  assert(typeof content === "string", "Unable to load previous JSON module");
+  return JSON.parse(content);
+}
+async function loadAsMagicast(getter) {
+  const content = await getter?.();
+  assert(typeof content === "string", "Unable to load previous module");
+  return parseModule(content);
+}
+async function loadRelativeFileAsMagicast(relativePath, meta) {
+  const __filename = fileURLToPath(meta.url);
+  const __dirname = dirname(__filename);
+  return loadFile(join(__dirname, relativePath));
+}
+
+// src/magicast.ts
+import { loadFile as loadFile2, parseModule as parseModule2, generateCode as generateCode2 } from "magicast";
+import { addVitePlugin } from "magicast/helpers";
+
+// src/utils/package.ts
+function* deps(obj) {
+  if (obj.devDependencies) {
+    for (const key in obj.devDependencies) {
+      yield [key, obj.devDependencies[key]];
+    }
+  }
+  if (obj.dependencies) {
+    for (const key in obj.dependencies) {
+      yield [key, obj.dependencies[key]];
+    }
+  }
+}
+function* findKey(depsMap, keys) {
+  for (const key of keys) {
+    const value = depsMap.get(key);
+    if (!value) {
+      throw new Error(`key '${value}' not found in package.json`);
+    }
+    yield [key, value];
+  }
+}
+function addDependency(packageJson, scopedPackageJson, keys) {
+  packageJson.devDependencies ?? (packageJson.devDependencies = {});
+  packageJson.dependencies ?? (packageJson.dependencies = {});
+  const depsMap = new Map(deps(scopedPackageJson));
+  for (const [key, value] of findKey(depsMap, keys.devDependencies ?? [])) {
+    packageJson.devDependencies[key] = value;
+  }
+  for (const [key, value] of findKey(depsMap, keys.dependencies ?? [])) {
+    packageJson.dependencies[key] = value;
+  }
+  return packageJson;
+}
+export {
+  addDependency,
+  addVitePlugin,
+  features,
+  flags,
+  generateCode2 as generateCode,
+  loadAsJson,
+  loadAsMagicast,
+  loadFile2 as loadFile,
+  loadRelativeFileAsMagicast,
+  parseModule2 as parseModule,
+  transformAndGenerate
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@batijs/core",
+  "version": "0.0.3",
+  "description": "",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/eslint": "^8.37.0",
+    "@types/node": "^16.18.24",
+    "tsx": "^3.12.6",
+    "typescript": "^5.0.4",
+    "uvu": "^0.5.6",
+    "@batijs/tsup": "0.0.3"
+  },
+  "dependencies": {
+    "@typescript-eslint/eslint-plugin": "^5.59.2",
+    "@typescript-eslint/parser": "^5.59.2",
+    "ast-types": "^0.14.2",
+    "eslint": "^8.39.0",
+    "eslint-plugin-unused-imports": "^2.0.0",
+    "magicast": "^0.2.4"
+  },
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
+      "types": [
+        "./global.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "test": "NODE_OPTIONS='--loader tsx' uvu",
+    "build": "tsup"
+  }
+}