novaapp-sdk 1.4.1 → 1.4.2

package/bin/nova.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+// Nova CLI shebang wrapper.
+// Resolves the compiled `dist/cli.js` relative to this file so it works
+// whether the SDK is installed globally or locally (npx novaapp-sdk).
+
+import { createRequire } from 'node:module'
+import { fileURLToPath }  from 'node:url'
+import { resolve, dirname } from 'node:path'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+// Dynamic import so the error message is clear if build is missing
+let run
+try {
+  ;({ run } = await import(resolve(__dirname, '../dist/cli.js')))
+} catch {
+  console.error(
+    '\x1b[31m✖\x1b[0m  Could not load dist/cli.js — run \x1b[36mnpm run build\x1b[0m first.'
+  )
+  process.exit(1)
+}
+
+await run(process.argv.slice(2))

package/dist/chunk-53M2BTB5.mjs

@@ -0,0 +1,26 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+export {
+  __esm,
+  __export,
+  __toCommonJS
+};

package/dist/chunk-LMORGVJR.mjs

@@ -0,0 +1,124 @@
+// src/devtools/HotLoader.ts
+import { EventEmitter } from "events";
+import * as fs from "fs";
+import * as path from "path";
+var HotLoader = class extends EventEmitter {
+  constructor(watchPath, options = {}) {
+    super();
+    this.watcher = null;
+    this.debounceTimer = null;
+    this.lastChanged = null;
+    this.restartFn = null;
+    this.restarting = false;
+    this.watchPath = path.resolve(watchPath);
+    this.debounceMs = options.debounce ?? 250;
+    this.recursive = options.recursive ?? true;
+    this.extensions = new Set(
+      options.extensions ?? [".ts", ".js", ".mjs", ".cjs", ".json"]
+    );
+  }
+  // ── Lifecycle ──────────────────────────────────────────────────────────────
+  /**
+   * Start watching for file changes.
+   *
+   * Calling `start()` again after `stop()` is safe — it creates a new watcher.
+   */
+  start() {
+    if (this.watcher) return;
+    this.watcher = fs.watch(
+      this.watchPath,
+      { recursive: this.recursive, encoding: "utf8" },
+      (event, filename) => {
+        if (!filename) return;
+        const ext = path.extname(filename);
+        if (!this.extensions.has(ext)) return;
+        const full = path.join(this.watchPath, filename);
+        this.emit("change", full);
+        this.lastChanged = full;
+        if (this.debounceTimer) clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+          this.debounceTimer = null;
+          if (this.lastChanged) {
+            const f = this.lastChanged;
+            this.lastChanged = null;
+            this.emit("reload", f);
+            this.triggerRestart();
+          }
+        }, this.debounceMs);
+      }
+    );
+    this.watcher.on("error", (err) => {
+      this.emit("error", err);
+    });
+  }
+  /**
+   * Stop watching.  Safe to call even if not started.
+   */
+  stop() {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+  }
+  // ── Restart helper ─────────────────────────────────────────────────────────
+  /**
+   * Register a callback that runs after every debounced `reload` event.
+   *
+   * If the callback is already running when another reload fires it will be
+   * queued once and run again after the current run finishes.
+   *
+   * @example
+   * ```ts
+   * loader.restart(async () => {
+   *   await client.disconnect()
+   *   await build()
+   *   await client.connect()
+   * })
+   * ```
+   */
+  restart(fn) {
+    this.restartFn = fn;
+  }
+  triggerRestart() {
+    if (!this.restartFn || this.restarting) return;
+    const fn = this.restartFn;
+    this.restarting = true;
+    const result = fn();
+    const finish = () => {
+      this.restarting = false;
+    };
+    if (result instanceof Promise) {
+      result.then(finish, (err) => {
+        finish();
+        this.emit("error", err instanceof Error ? err : new Error(String(err)));
+      });
+    } else {
+      finish();
+    }
+  }
+  // ── Typed event overloads ──────────────────────────────────────────────────
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+  /** Whether the loader is currently active. */
+  get watching() {
+    return this.watcher !== null;
+  }
+};
+
+export {
+  HotLoader
+};

package/dist/cli/index.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Main CLI dispatcher.  Keeps `index.ts` clean and avoids circular imports.
+ */
+declare function run(argv: string[]): Promise<void>;
+
+export { run };

package/dist/cli/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Main CLI dispatcher.  Keeps `index.ts` clean and avoids circular imports.
+ */
+declare function run(argv: string[]): Promise<void>;
+
+export { run };