@titanpl/packet 2.0.1 → 2.0.3

package/README.md

@@ -1,11 +1,11 @@
-# @titanpl/packet
-
-The internal bundler and module packer for Titan Planet.
-
-## What it works (What it does)
-This library parses all your app routes, components, middleware, and logic paths, then packages them into a static `build` output layer consisting of metadata files and JavaScript assets. 
-
-## How it works
-This package is triggered whenever you run `titan init` or `titan build` from the `@titanpl/cli`. It hooks into tools like `esbuild` to optimize your scripts efficiently. It strips unnecessary pieces out so that only explicit route actions make their way aggressively over to the Titan runtime engine.
-
-**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.
+# @titanpl/packet
+
+The internal bundler and module packer for Titan Planet.
+
+## What it works (What it does)
+This library parses all your app routes, components, middleware, and logic paths, then packages them into a static `build` output layer consisting of metadata files and JavaScript assets. 
+
+## How it works
+This package is triggered whenever you run `titan init` or `titan build` from the `@titanpl/cli`. It hooks into tools like `esbuild` to optimize your scripts efficiently. It strips unnecessary pieces out so that only explicit route actions make their way aggressively over to the Titan runtime engine.
+
+**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.

package/index.js

@@ -1,84 +1,84 @@
-import path from "path";
-import fs from "fs";
-
-/**
- * Get project type (js or ts)
- */
-function getProjectType(root) {
-  try {
-    const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
-    if (pkg.titan && pkg.titan.template && pkg.titan.template.includes("ts")) return "ts";
-  } catch (e) { }
-
-  if (fs.existsSync(path.join(root, "tsconfig.json"))) return "ts";
-  return "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 type = getProjectType(root);
-  const { bundle: bundleActions } = await import(`./${type}/titan/bundle.js`);
-  const { buildMetadata } = await import(`./${type}/titan/builder.js`);
-
-  const dist = ensureDist(root);
-
-  await buildMetadata(root, dist);
-  await bundleActions({
-    root,
-    outDir: dist,
-  });
-
-  return dist;
-}
-
-/**
- * Dev mode build
- */
-export async function dev(options = {}) {
-  const root = typeof options === 'string' ? options : (options.root || process.cwd());
-  const type = getProjectType(root);
-  const { dev: devServer } = await import(`./${type}/titan/dev.js`);
-
-  const dist = ensureDist(root);
-
-  await devServer({
-    root,
-    outDir: dist,
-    onRebuild: options.onRebuild
-  });
-
-  return dist;
-}
-
-/**
- * Direct export of current project tools
- */
-export async function getTools(root = process.cwd()) {
-  const type = getProjectType(root);
-  const bundleModule = await import(`./${type}/titan/bundle.js`);
-  const builderModule = await import(`./${type}/titan/builder.js`);
-  return {
-    bundleActions: bundleModule.bundle,
-    buildMetadata: builderModule.buildMetadata
-  };
+import path from "path";
+import fs from "fs";
+
+/**
+ * Get project type (js or ts)
+ */
+function getProjectType(root) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+    if (pkg.titan && pkg.titan.template && pkg.titan.template.includes("ts")) return "ts";
+  } catch (e) { }
+
+  if (fs.existsSync(path.join(root, "tsconfig.json"))) return "ts";
+  return "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 type = getProjectType(root);
+  const { bundle: bundleActions } = await import(`./${type}/titan/bundle.js`);
+  const { buildMetadata } = await import(`./${type}/titan/builder.js`);
+
+  const dist = ensureDist(root);
+
+  await buildMetadata(root, dist);
+  await bundleActions({
+    root,
+    outDir: dist,
+  });
+
+  return dist;
+}
+
+/**
+ * Dev mode build
+ */
+export async function dev(options = {}) {
+  const root = typeof options === 'string' ? options : (options.root || process.cwd());
+  const type = getProjectType(root);
+  const { dev: devServer } = await import(`./${type}/titan/dev.js`);
+
+  const dist = ensureDist(root);
+
+  await devServer({
+    root,
+    outDir: dist,
+    onRebuild: options.onRebuild
+  });
+
+  return dist;
+}
+
+/**
+ * Direct export of current project tools
+ */
+export async function getTools(root = process.cwd()) {
+  const type = getProjectType(root);
+  const bundleModule = await import(`./${type}/titan/bundle.js`);
+  const builderModule = await import(`./${type}/titan/builder.js`);
+  return {
+    bundleActions: bundleModule.bundle,
+    buildMetadata: builderModule.buildMetadata
+  };
 }

package/js/titan/builder.js

@@ -1,50 +1,50 @@
-import fs from "fs";
-import path from "path";
-import { pathToFileURL } from "url";
-
-export async function buildMetadata(root, dist) {
-    const appDir = path.join(root, "app");
-    const appFile = "app.js";
-    const appPath = path.join(appDir, appFile);
-
-    if (!fs.existsSync(appPath)) {
-        console.error(`\x1b[31m❌ app/${appFile} not found.\x1b[0m`);
-        process.exit(1);
-    }
-
-    try {
-        const appUrl = pathToFileURL(appPath).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("\x1b[31m❌ Failed to parse routes from app.js\x1b[0m", err);
-        process.exit(1);
-    }
-}
+import fs from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+
+export async function buildMetadata(root, dist) {
+    const appDir = path.join(root, "app");
+    const appFile = "app.js";
+    const appPath = path.join(appDir, appFile);
+
+    if (!fs.existsSync(appPath)) {
+        console.error(`\x1b[31m❌ app/${appFile} not found.\x1b[0m`);
+        process.exit(1);
+    }
+
+    try {
+        const appUrl = pathToFileURL(appPath).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("\x1b[31m❌ Failed to parse routes from app.js\x1b[0m", err);
+        process.exit(1);
+    }
+}

package/js/titan/bundle.js

@@ -1,164 +1,164 @@
-/**
- * Bundle.js (JavaScript Version)
- * Handles esbuild bundling with error reporting
- */
-
-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
- */
-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",
-};
-
-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(`[TitanPL] Failed to resolve Node shim: ${NODE_BUILTIN_MAP[args.path]}`);
-        }
-      }
-    });
-  }
-};
-
-function getTitanVersion() {
-  try {
-    const pkgPath = require.resolve("@titanpl/cli/package.json");
-    return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
-  } catch (e) {
-    return "1.0.0";
-  }
-}
-
-export class BundleError extends Error {
-  constructor(message, errors = [], warnings = []) {
-    super(message);
-    this.name = 'BundleError';
-    this.errors = errors;
-    this.warnings = warnings;
-    this.isBundleError = true;
-  }
-}
-
-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 } }]);
-  }
-}
-
-/**
- * Bundles a single file
- */
-export async function bundleFile(options) {
-  const { entryPoint, outfile, format = 'iife', globalName = '__titan_exports', target = 'es2020' } = options;
-
-  await validateEntryPoint(entryPoint);
-
-  const outDir = path.dirname(outfile);
-  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
-
-  try {
-    const result = await esbuild.build({
-      entryPoints: [entryPoint],
-      bundle: true,
-      outfile,
-      format,
-      globalName,
-      platform: 'node',
-      target,
-      logLevel: 'silent',
-      plugins: [titanNodeCompatPlugin],
-      banner: { js: "var Titan = t;" },
-      footer: options.footer || {}
-    });
-
-    if (result.errors?.length) {
-      throw new BundleError(`Build failed`, result.errors);
-    }
-  } catch (err) {
-    if (err.errors) throw new BundleError(`Build failed`, err.errors);
-    throw err;
-  }
-}
-
-/**
- * Main JS Bundler
- */
-export async function bundle(options = {}) {
-  const root = options.root || process.cwd();
-  const outDir = options.outDir || path.join(root, 'dist');
-  const titanVersion = getTitanVersion();
-
-  const actionsDir = path.join(root, 'app', 'actions');
-  const bundleDir = path.join(outDir, 'actions');
-
-  if (fs.existsSync(bundleDir)) fs.rmSync(bundleDir, { recursive: true, force: true });
-  fs.mkdirSync(bundleDir, { recursive: true });
-
-  if (!fs.existsSync(actionsDir)) return;
-
-  const files = fs.readdirSync(actionsDir).filter(f => f.endsWith('.js'));
-
-  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,
-        footer: {
-          js: `
-(function () {
-  const fn = __titan_exports["${actionName}"] || __titan_exports.default;
-  if (typeof fn !== "function") throw new Error("[TitanPL] Action '${actionName}' not found or not a function");
-  globalThis["${actionName}"] = globalThis.defineAction(fn);
-})();`
-        }
-      });
-    } catch (error) {
-      console.error();
-      if (error.isBundleError && error.errors?.length) {
-        for (const err of error.errors) {
-          const errorInfo = parseEsbuildError(err);
-          errorInfo.titanVersion = titanVersion;
-          console.error(renderErrorBox(errorInfo));
-          console.error();
-        }
-      } else {
-        console.error(renderErrorBox({ title: 'Build Error', message: error.message, titanVersion }));
-      }
-      throw new Error('__TITAN_BUNDLE_FAILED__');
-    }
-  }
-}
+/**
+ * Bundle.js (JavaScript Version)
+ * Handles esbuild bundling with error reporting
+ */
+
+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
+ */
+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",
+};
+
+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(`[TitanPL] Failed to resolve Node shim: ${NODE_BUILTIN_MAP[args.path]}`);
+        }
+      }
+    });
+  }
+};
+
+function getTitanVersion() {
+  try {
+    const pkgPath = require.resolve("@titanpl/cli/package.json");
+    return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+  } catch (e) {
+    return "1.0.0";
+  }
+}
+
+export class BundleError extends Error {
+  constructor(message, errors = [], warnings = []) {
+    super(message);
+    this.name = 'BundleError';
+    this.errors = errors;
+    this.warnings = warnings;
+    this.isBundleError = true;
+  }
+}
+
+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 } }]);
+  }
+}
+
+/**
+ * Bundles a single file
+ */
+export async function bundleFile(options) {
+  const { entryPoint, outfile, format = 'iife', globalName = '__titan_exports', target = 'es2020' } = options;
+
+  await validateEntryPoint(entryPoint);
+
+  const outDir = path.dirname(outfile);
+  if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+
+  try {
+    const result = await esbuild.build({
+      entryPoints: [entryPoint],
+      bundle: true,
+      outfile,
+      format,
+      globalName,
+      platform: 'node',
+      target,
+      logLevel: 'silent',
+      plugins: [titanNodeCompatPlugin],
+      banner: { js: "var Titan = t;" },
+      footer: options.footer || {}
+    });
+
+    if (result.errors?.length) {
+      throw new BundleError(`Build failed`, result.errors);
+    }
+  } catch (err) {
+    if (err.errors) throw new BundleError(`Build failed`, err.errors);
+    throw err;
+  }
+}
+
+/**
+ * Main JS Bundler
+ */
+export async function bundle(options = {}) {
+  const root = options.root || process.cwd();
+  const outDir = options.outDir || path.join(root, 'dist');
+  const titanVersion = getTitanVersion();
+
+  const actionsDir = path.join(root, 'app', 'actions');
+  const bundleDir = path.join(outDir, 'actions');
+
+  if (fs.existsSync(bundleDir)) fs.rmSync(bundleDir, { recursive: true, force: true });
+  fs.mkdirSync(bundleDir, { recursive: true });
+
+  if (!fs.existsSync(actionsDir)) return;
+
+  const files = fs.readdirSync(actionsDir).filter(f => f.endsWith('.js'));
+
+  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,
+        footer: {
+          js: `
+(function () {
+  const fn = __titan_exports["${actionName}"] || __titan_exports.default;
+  if (typeof fn !== "function") throw new Error("[TitanPL] Action '${actionName}' not found or not a function");
+  globalThis["${actionName}"] = globalThis.defineAction(fn);
+})();`
+        }
+      });
+    } catch (error) {
+      console.error();
+      if (error.isBundleError && error.errors?.length) {
+        for (const err of error.errors) {
+          const errorInfo = parseEsbuildError(err);
+          errorInfo.titanVersion = titanVersion;
+          console.error(renderErrorBox(errorInfo));
+          console.error();
+        }
+      } else {
+        console.error(renderErrorBox({ title: 'Build Error', message: error.message, titanVersion }));
+      }
+      throw new Error('__TITAN_BUNDLE_FAILED__');
+    }
+  }
+}