@batijs/build 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# @batijs/build
+
+WIP

package/dist/chunk-3EUYSS5H.js

@@ -0,0 +1,107 @@
+import {
+  evalCondition
+} from "./chunk-U7QQNTGA.js";
+import {
+  lazyfy
+} from "./chunk-5XFUXMWM.js";
+
+// src/parse.ts
+import recast, { print, prettyPrint, types } from "recast";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function ast(code) {
+  return recast.parse(code, {
+    parser: require2("recast/parsers/typescript")
+  });
+}
+function simpleAstExpression(code) {
+  return ast(code).body[0];
+}
+var metaAst = lazyfy({
+  VIKE_FRAMEWORK: () => simpleAstExpression("import.meta.VIKE_FRAMEWORK"),
+  VIKE_DATABASE: () => simpleAstExpression("import.meta.VIKE_DATABASE")
+});
+function transformAst(tree, meta) {
+  const imports = /* @__PURE__ */ new Map();
+  const identifiers = /* @__PURE__ */ new Set();
+  types.visit(tree, {
+    visitIdentifier(path) {
+      if (path.value.name === "VIKE_REMOVE") {
+        if (!path.parent) {
+          throw new Error("TODO");
+        }
+        if (!types.namedTypes.ArrayExpression.check(path.parent?.parent?.value)) {
+          throw new Error("TODO: Not supported");
+        }
+        path.parent.prune();
+        this.traverse(path);
+        return;
+      }
+      if (types.namedTypes.ImportDefaultSpecifier.check(path.parent.value) || types.namedTypes.ImportSpecifier.check(path.parent.value)) {
+        let importParent = path.parent;
+        while (importParent.value && importParent.value.type !== "ImportDeclaration") {
+          importParent = importParent.parent;
+        }
+        imports.set(path.value.name, importParent);
+      } else {
+        identifiers.add(path.value.name);
+      }
+      this.traverse(path);
+    },
+    visitConditionalExpression(path) {
+      this.visitIfStatement(path);
+    },
+    visitIfStatement(path) {
+      let found = false;
+      this.traverse(path.get("test"), {
+        visitMemberExpression(path2) {
+          if (print(path2.value).code.startsWith("import.meta.VIKE_")) {
+            found = true;
+          }
+          this.traverse(path2);
+        }
+      });
+      if (!found) {
+        this.traverse(path);
+        return;
+      }
+      if (!evalCondition(print(path.value.test).code, meta)) {
+        if (path.value.alternate) {
+          if (types.namedTypes.BlockStatement.check(path.value.alternate)) {
+            path.replace(...path.value.alternate.body);
+          } else {
+            path.replace(path.value.alternate);
+          }
+        } else {
+          path.prune();
+        }
+      } else {
+        if (types.namedTypes.BlockStatement.check(path.value.consequent)) {
+          path.replace(...path.value.consequent.body);
+        } else {
+          path.replace(path.value.consequent);
+        }
+      }
+      this.traverse(path.parent ? path.parent : path);
+    }
+  });
+  const importsToRemove = new Set(
+    Array.from(imports.entries()).filter(([name]) => !identifiers.has(name)).map(([, node]) => node)
+  );
+  importsToRemove.forEach((node) => node.prune());
+  return tree;
+}
+function transform(tree, meta) {
+  return prettyPrint(transformAst(tree, meta), {
+    tabWidth: 2,
+    reuseWhitespace: false,
+    wrapColumn: 120
+  }).code;
+}
+
+export {
+  ast,
+  metaAst,
+  transformAst,
+  transform
+};

package/dist/chunk-5XFUXMWM.js

@@ -0,0 +1,24 @@
+// src/utils.ts
+function lazyGetter(obj, key, getter) {
+  Object.defineProperty(obj, key, {
+    enumerable: false,
+    configurable: true,
+    get() {
+      delete this[key];
+      this[key] = getter();
+      return this[key];
+    }
+  });
+}
+function lazyfy(obj) {
+  const ret = {};
+  for (const [k, getter] of Object.entries(obj)) {
+    lazyGetter(ret, k, getter);
+  }
+  return ret;
+}
+
+export {
+  lazyGetter,
+  lazyfy
+};

package/dist/chunk-U7QQNTGA.js

@@ -0,0 +1,26 @@
+// src/eval.ts
+import ts from "typescript";
+function evalCondition(obj, meta = {}) {
+  obj = obj.replaceAll("import.meta", "VIKE_META");
+  obj = `var VIKE_META = ${JSON.stringify(meta)};(${obj})`;
+  obj = ts.transpile(obj, {
+    strict: true,
+    allowJs: true,
+    checkJs: true,
+    esModuleInterop: true,
+    forceConsistentCasingInFileNames: true,
+    resolveJsonModule: true,
+    skipLibCheck: true,
+    sourceMap: false,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.Node10,
+    target: ts.ScriptTarget.ES2020,
+    lib: ["DOM", "DOM.Iterable", "ESNext"],
+    types: ["@types/node"]
+  });
+  return (0, eval)(obj);
+}
+
+export {
+  evalCondition
+};

package/dist/eval.d.ts

@@ -0,0 +1,3 @@
+declare function evalCondition(obj: string, meta?: VikeMeta): any;
+
+export { evalCondition };

package/dist/eval.js

@@ -0,0 +1,6 @@
+import {
+  evalCondition
+} from "./chunk-U7QQNTGA.js";
+export {
+  evalCondition
+};

package/dist/exec.d.ts

@@ -0,0 +1,5 @@
+declare function main(options: {
+    dist: string;
+}, meta: VikeMeta): Promise<void>;
+
+export { main as default };

package/dist/exec.js

@@ -0,0 +1,103 @@
+import {
+  ast,
+  transform
+} from "./chunk-3EUYSS5H.js";
+import "./chunk-U7QQNTGA.js";
+import "./chunk-5XFUXMWM.js";
+
+// src/exec.ts
+import { readFile, opendir, copyFile, mkdir, writeFile, unlink } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var __files = path.resolve(__dirname, "..", "files");
+function evalDirCondition(obj, meta) {
+  obj = obj.replaceAll("VIKE_", "VIKE_META.VIKE_");
+  obj = `var VIKE_META = ${JSON.stringify(meta)};(${obj})`;
+  return (0, eval)(obj);
+}
+function shouldWalkDir(dirname, meta) {
+  if (!dirname.includes("VIKE_"))
+    return true;
+  return evalDirCondition(dirname, meta);
+}
+function toDist(filepath, dist) {
+  const split = filepath.split(path.sep).filter((p) => !p.includes("VIKE_"));
+  split[split.length - 1] = split[split.length - 1].replace(/^\$(.*)\.ts$/, "$1");
+  return split.join(path.sep).replace(__files, dist);
+}
+async function safeCopyFile(source, destination) {
+  const destinationDir = path.dirname(destination);
+  await mkdir(destinationDir, {
+    recursive: true
+  });
+  await copyFile(source, destination);
+}
+async function safeWriteFile(destination, content) {
+  const destinationDir = path.dirname(destination);
+  await mkdir(destinationDir, {
+    recursive: true
+  });
+  await writeFile(destination, content, { encoding: "utf-8" });
+}
+async function* walk(dir, meta) {
+  for await (const d of await opendir(dir)) {
+    const entry = path.join(dir, d.name);
+    if (d.isDirectory()) {
+      if (shouldWalkDir(d.name, meta)) {
+        yield* walk(entry, meta);
+      }
+    } else if (d.isFile())
+      yield entry;
+  }
+}
+function transformFileAfterExec(filepath, fileContent) {
+  const parsed = path.parse(filepath);
+  switch (parsed.ext) {
+    case ".json":
+      return JSON.stringify(fileContent, null, 2);
+    default:
+      throw new Error(`Unsupported extension ${parsed.ext} (${filepath})`);
+  }
+}
+async function main(options, meta) {
+  for await (const p of walk(__files, meta)) {
+    const target = toDist(p, options.dist);
+    if (p.match(/\.[tj]sx?$/)) {
+      let code;
+      try {
+        const tree = ast(await readFile(p, { encoding: "utf8" }));
+        code = transform(tree, meta);
+      } catch (e) {
+        console.error(`File: ${p}`);
+        throw e;
+      }
+      const parsed = path.parse(p);
+      if (parsed.name.startsWith("$")) {
+        const tmpfile = path.join(
+          parsed.dir,
+          `${parsed.name}.${(/* @__PURE__ */ new Date()).toISOString().replaceAll(":", "-")}${parsed.ext}`
+        );
+        let fileContent = null;
+        try {
+          await writeFile(tmpfile, code, { encoding: "utf-8" });
+          const f = await import(tmpfile);
+          fileContent = transformFileAfterExec(target, await f.default());
+        } finally {
+          await unlink(tmpfile);
+        }
+        if (fileContent !== null) {
+          await safeWriteFile(target, fileContent);
+        }
+      } else {
+        await safeWriteFile(target, code);
+      }
+    } else {
+      await safeCopyFile(p, target);
+    }
+  }
+}
+export {
+  main as default
+};

package/dist/parse.d.ts

@@ -0,0 +1,11 @@
+import recast from 'recast';
+
+declare function ast(code: string): any;
+declare const metaAst: {
+    VIKE_FRAMEWORK: recast.types.namedTypes.ExpressionStatement;
+    VIKE_DATABASE: recast.types.namedTypes.ExpressionStatement;
+};
+declare function transformAst(tree: ReturnType<typeof ast>, meta: VikeMeta): any;
+declare function transform(tree: ReturnType<typeof ast>, meta: VikeMeta): string;
+
+export { ast, metaAst, transform, transformAst };

package/dist/parse.js

@@ -0,0 +1,14 @@
+import {
+  ast,
+  metaAst,
+  transform,
+  transformAst
+} from "./chunk-3EUYSS5H.js";
+import "./chunk-U7QQNTGA.js";
+import "./chunk-5XFUXMWM.js";
+export {
+  ast,
+  metaAst,
+  transform,
+  transformAst
+};

package/dist/testUtils.d.ts

@@ -0,0 +1,6 @@
+import { ast } from './parse.js';
+import 'recast';
+
+declare function assertEquivalentAst(ast1: ReturnType<typeof ast>, ast2: ReturnType<typeof ast>): void;
+
+export { assertEquivalentAst };