@titanpl/packet 1.0.0

package/index.js

@@ -0,0 +1,63 @@
+import path from "path";
+import fs from "fs";
+
+import { bundle as bundleActions } from "./js/titan/bundle.js";
+import { dev as devServer } from "./js/titan/dev.js";
+import { buildMetadata } from "./js/titan/builder.js";
+
+/**
+ * Ensure dist directory exists
+ */
+function ensureDist(root) {
+  const dist = path.join(root, "dist");
+  const actions = path.join(dist, "actions");
+
+  if (!fs.existsSync(dist)) {
+    fs.mkdirSync(dist, { recursive: true });
+  }
+
+  if (!fs.existsSync(actions)) {
+    fs.mkdirSync(actions, { recursive: true });
+  }
+
+  return dist;
+}
+
+/**
+ * Production build
+ */
+export async function build(root = process.cwd()) {
+  const dist = ensureDist(root);
+
+  await buildMetadata(root, dist);
+  await bundleActions({
+    root,
+    outDir: dist,
+  });
+
+  return dist;
+}
+
+/**
+ * Dev mode build (watch mode handled inside dev.js)
+ */
+export async function dev(options = {}) {
+  const root = typeof options === 'string' ? options : (options.root || process.cwd());
+  const dist = ensureDist(root);
+
+  await devServer({
+    root,
+    outDir: dist,
+    onRebuild: options.onRebuild
+  });
+
+  return dist;
+}
+
+/**
+ * Direct export of lower-level tools (optional)
+ */
+export {
+  bundleActions,
+  buildMetadata
+};

package/js/titan/builder.js

@@ -0,0 +1,73 @@
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+
+export async function buildMetadata(root, dist) {
+    const appJsPath = path.join(root, "app", "app.js");
+    const appTsPath = path.join(root, "app", "app.ts");
+
+    if (!fs.existsSync(appJsPath) && !fs.existsSync(appTsPath)) {
+        console.error("❌ app/app.js or app/app.ts not found.");
+        process.exit(1);
+    }
+
+    // Load the app file to populate globalThis.__TITAN_ROUTES_MAP__
+    try {
+        let appUrl;
+        if (fs.existsSync(appTsPath)) {
+            const dotTitan = path.join(root, ".titan");
+            const compiledApp = path.join(dotTitan, "app.js");
+
+            if (!fs.existsSync(dotTitan)) {
+                fs.mkdirSync(dotTitan, { recursive: true });
+            }
+
+            const esbuild = await import("esbuild");
+            await esbuild.build({
+                entryPoints: [appTsPath],
+                outfile: compiledApp,
+                bundle: true,
+                platform: "node",
+                format: "esm",
+                packages: "external",
+                logLevel: "silent"
+            });
+            appUrl = pathToFileURL(compiledApp).href;
+        } else {
+            appUrl = pathToFileURL(appJsPath).href;
+        }
+
+        const cacheBuster = `?t=${Date.now()}`;
+        await import(appUrl + cacheBuster);
+
+        const config = globalThis.__TITAN_CONFIG__ || { port: 3000, threads: 4, stack_mb: 8 };
+        const routes = globalThis.__TITAN_ROUTES_MAP__ || {};
+        const dynamicRoutes = globalThis.__TITAN_DYNAMIC_ROUTES__ || {};
+        const actionMap = globalThis.__TITAN_ACTION_MAP__ || {};
+
+        const routesPath = path.join(dist, "routes.json");
+        const actionMapPath = path.join(dist, "action_map.json");
+
+        fs.writeFileSync(
+            routesPath,
+            JSON.stringify(
+                {
+                    __config: config,
+                    routes,
+                    __dynamic_routes: Object.values(dynamicRoutes).flat()
+                },
+                null,
+                2
+            )
+        );
+
+        fs.writeFileSync(
+            actionMapPath,
+            JSON.stringify(actionMap, null, 2)
+        );
+
+    } catch (err) {
+        console.error("❌ Failed to parse routes from app.js", err);
+        process.exit(1);
+    }
+}

package/js/titan/bundle.js

@@ -0,0 +1,261 @@
+/**
+ * Bundle.js
+ * Handles esbuild bundling with comprehensive error reporting
+ * RULE: This file handles ALL esbuild errors and prints error boxes directly
+ */
+
+import esbuild from 'esbuild';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import { renderErrorBox, parseEsbuildError } from './error-box.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Required for resolving node_modules inside ESM
+const require = createRequire(import.meta.url);
+
+/**
+ * Titan Node Builtin Rewrite Map
+ * Rewrites Node builtins to @titanpl/node shims
+ */
+const NODE_BUILTIN_MAP = {
+  "fs": "@titanpl/node/fs",
+  "node:fs": "@titanpl/node/fs",
+
+  "path": "@titanpl/node/path",
+  "node:path": "@titanpl/node/path",
+
+  "os": "@titanpl/node/os",
+  "node:os": "@titanpl/node/os",
+
+  "crypto": "@titanpl/node/crypto",
+  "node:crypto": "@titanpl/node/crypto",
+
+  "process": "@titanpl/node/process",
+
+  "util": "@titanpl/node/util",
+  "node:util": "@titanpl/node/util",
+};
+
+/**
+ * Titan Node Compatibility Plugin
+ * Rewrites require/import of Node builtins
+ * Returns absolute paths (required by esbuild)
+ */
+const titanNodeCompatPlugin = {
+  name: "titan-node-compat",
+  setup(build) {
+    build.onResolve({ filter: /.*/ }, args => {
+      if (NODE_BUILTIN_MAP[args.path]) {
+        try {
+          const resolved = require.resolve(NODE_BUILTIN_MAP[args.path]);
+          return { path: resolved };
+        } catch (e) {
+          throw new Error(
+            `[Titan] Failed to resolve Node shim: ${NODE_BUILTIN_MAP[args.path]}`
+          );
+        }
+      }
+    });
+  }
+};
+
+/**
+ * Get Titan version for error branding
+ */
+function getTitanVersion() {
+  try {
+    const pkgPath = require.resolve("@ezetgalaxy/titan/package.json");
+    return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+  } catch (e) {
+    return "0.1.0";
+  }
+}
+
+/**
+ * Custom error class for bundle errors
+ */
+export class BundleError extends Error {
+  constructor(message, errors = [], warnings = []) {
+    super(message);
+    this.name = 'BundleError';
+    this.errors = errors;
+    this.warnings = warnings;
+    this.isBundleError = true;
+  }
+}
+
+/**
+ * Validate entry file exists
+ */
+async function validateEntryPoint(entryPoint) {
+  const absPath = path.resolve(entryPoint);
+
+  if (!fs.existsSync(absPath)) {
+    throw new BundleError(
+      `Entry point does not exist: ${entryPoint}`,
+      [{ text: `Cannot find file: ${absPath}`, location: { file: entryPoint } }]
+    );
+  }
+
+  try {
+    await fs.promises.access(absPath, fs.constants.R_OK);
+  } catch {
+    throw new BundleError(
+      `Entry point is not readable: ${entryPoint}`,
+      [{ text: `Cannot read file: ${absPath}`, location: { file: entryPoint } }]
+    );
+  }
+}
+
+/**
+ * Bundles a single file
+ */
+export async function bundleFile(options) {
+  const {
+    entryPoint,
+    outfile,
+    format = 'iife',
+    minify = false,
+    sourcemap = false,
+    platform = 'neutral',
+    globalName = '__titan_exports',
+    target = 'es2020',
+    banner = {},
+    footer = {}
+  } = options;
+
+  await validateEntryPoint(entryPoint);
+
+  const outDir = path.dirname(outfile);
+  await fs.promises.mkdir(outDir, { recursive: true });
+
+  try {
+    const result = await esbuild.build({
+      entryPoints: [entryPoint],
+      bundle: true,
+      outfile,
+      format,
+      globalName,
+      platform,
+      target,
+      banner,
+      footer,
+      minify,
+      sourcemap,
+      logLevel: 'silent',
+      logLimit: 0,
+      write: true,
+      metafile: false,
+      plugins: [titanNodeCompatPlugin],
+    });
+
+    if (result.errors?.length) {
+      throw new BundleError(
+        `Build failed with ${result.errors.length} error(s)`,
+        result.errors,
+        result.warnings || []
+      );
+    }
+
+  } catch (err) {
+    if (err.errors?.length) {
+      throw new BundleError(
+        `Build failed with ${err.errors.length} error(s)`,
+        err.errors,
+        err.warnings || []
+      );
+    }
+
+    throw new BundleError(
+      `Unexpected build error: ${err.message}`,
+      [{ text: err.message, location: { file: entryPoint } }]
+    );
+  }
+}
+
+/**
+ * Main bundler
+ */
+export async function bundle(options = {}) {
+  const root = options.root || process.cwd();
+  const outDir = options.outDir || path.join(root, 'dist');
+
+  const actionsDir = path.join(root, 'app', 'actions');
+  const bundleDir = path.join(outDir, 'actions');
+
+  if (fs.existsSync(bundleDir)) {
+    fs.rmSync(bundleDir, { recursive: true, force: true });
+  }
+  await fs.promises.mkdir(bundleDir, { recursive: true });
+
+  if (!fs.existsSync(actionsDir)) return;
+
+  const files = fs.readdirSync(actionsDir).filter(f =>
+    (f.endsWith('.js') || f.endsWith('.ts')) && !f.endsWith('.d.ts')
+  );
+
+  for (const file of files) {
+    const actionName = path.basename(file, path.extname(file));
+    const entryPoint = path.join(actionsDir, file);
+    const outfile = path.join(bundleDir, actionName + ".jsbundle");
+
+    try {
+      await bundleFile({
+        entryPoint,
+        outfile,
+        format: 'iife',
+        globalName: '__titan_exports',
+        platform: 'node',
+        target: 'es2020',
+        banner: { js: "var Titan = t;" },
+        footer: {
+          js: `
+(function () {
+  const fn =
+    __titan_exports["${actionName}"] ||
+    __titan_exports.default;
+
+  if (typeof fn !== "function") {
+    throw new Error("[Titan] Action '${actionName}' not found or not a function");
+  }
+
+  globalThis["${actionName}"] = globalThis.defineAction(fn);
+})();
+`
+        }
+      });
+
+    } catch (error) {
+
+      console.error();
+
+      const titanVersion = getTitanVersion();
+
+      if (error.isBundleError && error.errors?.length) {
+        for (let i = 0; i < error.errors.length; i++) {
+          const errorInfo = parseEsbuildError(error.errors[i]);
+          if (error.errors.length > 1) {
+            errorInfo.title = `Build Error ${i + 1}/${error.errors.length}`;
+          }
+          errorInfo.titanVersion = titanVersion;
+          console.error(renderErrorBox(errorInfo));
+          console.error();
+        }
+      } else {
+        const errorInfo = {
+          title: 'Build Error',
+          file: entryPoint,
+          message: error.message || 'Unknown error',
+          titanVersion
+        };
+        console.error(renderErrorBox(errorInfo));
+      }
+
+      throw new Error('__TITAN_BUNDLE_FAILED__');
+    }
+  }
+}

package/js/titan/dev.js

@@ -0,0 +1,85 @@
+import chokidar from "chokidar";
+import path from "path";
+import fs from "fs";
+import { bundle } from "./bundle.js";
+import { buildMetadata } from "./builder.js";
+import { createRequire } from "module";
+
+const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
+const green = (t) => `\x1b[32m${t}\x1b[0m`;
+const yellow = (t) => `\x1b[33m${t}\x1b[0m`;
+const red = (t) => `\x1b[31m${t}\x1b[0m`;
+const gray = (t) => `\x1b[90m${t}\x1b[0m`;
+const bold = (t) => `\x1b[1m${t}\x1b[0m`;
+
+function getTitanVersion() {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgPath = require.resolve("@titanpl/cli/package.json");
+        return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+    } catch (e) {
+        return "1.0.0";
+    }
+}
+
+export async function dev(options) {
+    const root = options.root || process.cwd();
+    const outDir = options.outDir || path.join(root, "dist");
+    const onRebuild = options.onRebuild || (() => { });
+
+    const isTs = fs.existsSync(path.join(root, "tsconfig.json")) || fs.existsSync(path.join(root, "app", "app.ts"));
+    const actionsDir = path.join(root, "app", "actions");
+    let hasRust = false;
+    if (fs.existsSync(actionsDir)) {
+        hasRust = fs.readdirSync(actionsDir).some(f => f.endsWith(".rs"));
+    }
+
+    let mode = "";
+    if (hasRust) {
+        mode = isTs ? "Rust + TS Actions" : "Rust + JS Actions";
+    } else {
+        mode = isTs ? "TS Actions" : "JS Actions";
+    }
+    const version = getTitanVersion();
+
+    console.clear();
+    console.log("");
+    console.log(`  ${bold(cyan("⏣ Titan Planet"))}   ${gray("v" + version)}   ${yellow("[ Dev Mode ]")}`);
+    console.log("");
+    console.log(`  ${gray("Type:       ")} ${mode}`);
+    console.log(`  ${gray("Hot Reload: ")} ${green("Enabled")}`);
+
+    if (fs.existsSync(path.join(root, ".env"))) {
+        console.log(`  ${gray("Env:        ")} ${yellow("Loaded")}`);
+    }
+    console.log("");
+
+    // Initial build
+    await buildMetadata(root, outDir);
+    await bundle({ root, outDir });
+
+    // Watch for changes inside app/
+    const appDir = path.join(root, "app");
+    const envFile = path.join(root, ".env");
+
+    const watcher = chokidar.watch([appDir, envFile], {
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 300, pollInterval: 100 }
+    });
+
+    watcher.on("all", async (event, file) => {
+        if (!file) return;
+        const relPath = path.relative(root, file);
+        if (relPath.startsWith("dist") || relPath.startsWith("server")) return;
+
+        try {
+            await buildMetadata(root, outDir);
+            await bundle({ root, outDir });
+            onRebuild();
+        } catch (err) {
+            console.error(red(`[Titan] Build failed, awaiting changes...`));
+        }
+    });
+
+    return watcher;
+}