@devaloop/devalang 0.0.1-alpha.16-hotfix.3 → 0.0.1-alpha.18

package/tests/typescript/index.spec.ts

@@ -0,0 +1,136 @@
+import { expect } from "chai";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+// CommonJS bundle import (TypeScript-friendly)
+const core: any = require("../../out-tsc");
+
+describe("devalang typescript index", () => {
+  let origCwd: string;
+  let tmpDir: string | null = null;
+
+  before(function () {
+    // Prepare a temporary project root so wasm code that looks up project files
+    // and `.devalang` config can succeed during E2E runs.
+    origCwd = process.cwd();
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "devalang-e2e-"));
+    // Create minimal .devalang config file so get_project_root finds it
+    fs.writeFileSync(
+      path.join(tmpDir, ".devalang"),
+      'name = "devalang-test"\n'
+    );
+    // Ensure .deva exists (optional banks/plugins)
+    fs.mkdirSync(path.join(tmpDir, ".deva"), { recursive: true });
+    process.chdir(tmpDir);
+  });
+
+  after(function () {
+    // restore cwd and attempt cleanup
+    if (tmpDir) {
+      try {
+        process.chdir(origCwd);
+        // best-effort cleanup
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      } catch (e) {
+        // ignore
+      }
+    }
+  });
+  it("should expose render_audio and return a Float32Array when wasm is available", function () {
+    // Prefer wasm binding if available
+    const wasmFn = core.pkg && core.pkg.render_audio;
+
+    const sampleProgram = `# simple program for tests
+bpm 120
+
+group myLead:
+  let mySynth = synth sine
+  mySynth -> note(C4, { duration: 400 })
+  mySynth -> note(G4, { duration: 400 })
+call myLead
+`;
+
+    if (typeof wasmFn === "function") {
+      try {
+        // Get parsed AST first for debugging
+        if (core.pkg && typeof core.pkg.parse === "function") {
+          try {
+            const parsed = core.pkg.parse("playground.deva", sampleProgram);
+            // parsed may be an object { ok, ast, errors } or a string
+            const astStr =
+              parsed && parsed.ast
+                ? parsed.ast
+                : typeof parsed === "string"
+                ? parsed
+                : JSON.stringify(parsed);
+            expect(astStr).to.match(/note|synth/i);
+          } catch (e) {
+            console.warn(
+              "[TEST DEBUG] parse() failed or returned non-standard result:",
+              e
+            );
+          }
+        }
+
+        const result = wasmFn(sampleProgram);
+        expect(result.constructor && result.constructor.name).to.match(
+          /Float32Array|Float64Array|ArrayBuffer|Uint8Array/
+        );
+      } catch (err: any) {
+        // If the wasm panicked because the audio buffer is empty, skip the test in this env.
+        const msg =
+          typeof err === "string"
+            ? err
+            : err && err.message
+            ? err.message
+            : String(err);
+        if (msg.includes("Audio buffer is empty")) {
+          // skip this test on environments where generating audio isn't supported
+          // eslint-disable-next-line no-invalid-this
+          this.skip();
+        }
+
+        throw err;
+      }
+
+      return;
+    }
+
+    // If wasm binding isn't available, ensure a runtime placeholder exists but don't call it
+    const runtimeFn = core.render_audio;
+    expect(runtimeFn).to.be.a("function");
+  });
+
+  it("should find statements for entry module", function () {
+    const parseFn = core.pkg && core.pkg.parse;
+    if (typeof parseFn !== "function") {
+      // nothing to test if parse binding missing
+      // eslint-disable-next-line no-invalid-this
+      this.skip();
+    }
+
+    try {
+      const res = parseFn("playground.deva", "bpm 120");
+      expect(res).to.be.an("object");
+      // prefer explicit shape when available
+      if (Object.prototype.hasOwnProperty.call(res, "ok")) {
+        expect(res.ok).to.equal(true);
+      } else {
+        expect(res).to.have.property("ast");
+      }
+    } catch (err: any) {
+      const msg = err && err.message ? err.message : String(err);
+      if (
+        msg.includes("Module loading error") ||
+        msg.includes("Project root not found")
+      ) {
+        // environment not prepared for module loading, skip
+        // eslint-disable-next-line no-invalid-this
+        this.skip();
+        return;
+      }
+      throw err;
+    }
+  });
+});

package/tests/typescript/playhead.spec.ts

@@ -0,0 +1,36 @@
+import { expect } from "chai";
+
+const core: any = require("../../out-tsc");
+
+describe("playhead callback", () => {
+  it("should call registered callback during run", () => {
+    const register = core.pkg && core.pkg.register_playhead_callback;
+    const unregister = core.pkg && core.pkg.unregister_playhead_callback;
+    if (typeof register !== "function") {
+      // skip when wasm not available
+      return;
+    }
+
+    let called = false;
+    const cb = (ev: any) => {
+      called = true;
+      expect(ev).to.have.property("time");
+      expect(ev).to.have.property("line");
+      expect(ev).to.have.property("column");
+    };
+
+    register(cb);
+
+    // run a simple program to trigger events
+    const program = `bpm 120\n\n.myTrigger 1/4\n`;
+    // render_audio will schedule triggers and should invoke the callback during execution
+    const render = core.pkg && core.pkg.render_audio;
+    if (typeof render === "function") {
+      render(program);
+    }
+
+    unregister && unregister();
+
+    expect(called).to.be.true;
+  });
+});

package/tests/typescript/render_e2e.spec.ts

@@ -0,0 +1,77 @@
+import { expect } from "chai";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+
+const core: any = require("../../out-tsc");
+
+describe("devalang debug_render and render_audio E2E", () => {
+  let origCwd: string;
+  let tmpDir: string | null = null;
+
+  before(function () {
+    origCwd = process.cwd();
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "devalang-e2e-"));
+    fs.writeFileSync(
+      path.join(tmpDir, ".devalang"),
+      'name = "devalang-test"\n'
+    );
+    fs.mkdirSync(path.join(tmpDir, ".deva"), { recursive: true });
+    process.chdir(tmpDir as string);
+  });
+
+  after(function () {
+    if (tmpDir) {
+      try {
+        process.chdir(origCwd);
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      } catch (e) {
+        // ignore
+      }
+    }
+  });
+
+  it("debug_render should return diagnostics including note_count and global_vars", function () {
+    const dbg = core.pkg && core.pkg.debug_render;
+    if (typeof dbg !== "function") {
+      // skip if wasm binding missing
+      // eslint-disable-next-line no-invalid-this
+      this.skip();
+    }
+
+    const sampleProgram = `# sample program\nbpm 120\n\ngroup myLead:\n  let mySynth = synth sine\n  mySynth -> note(C4, { duration: 400 })\n  mySynth -> note(G4, { duration: 400 })\ncall myLead\n`;
+
+    const out = dbg(sampleProgram);
+    expect(out).to.be.an("object");
+    expect(out).to.have.property("samples_len");
+    expect(out).to.have.property("any_nonzero");
+    expect(out).to.have.property("note_count");
+    expect(out).to.have.property("global_vars");
+
+    // Basic assertions: at least one non-zero sample or note_count > 0
+    expect(out.note_count).to.be.at.least(0);
+    expect(out.global_vars).to.include("myLead");
+  });
+
+  it("render_audio should return a Float32Array and not be completely silent", function () {
+    const render = (core.pkg && core.pkg.render_audio) || core.render_audio;
+    if (typeof render !== "function") {
+      // eslint-disable-next-line no-invalid-this
+      this.skip();
+    }
+
+    const sampleProgram = `# sample program\nbpm 120\n\ngroup myLead:\n  let mySynth = synth sine\n  mySynth -> note(C4, { duration: 400 })\n  mySynth -> note(G4, { duration: 400 })\ncall myLead\n`;
+
+    const arr = render(sampleProgram);
+    // If wasm returns JS typed array wrapper, check constructor name
+    expect(arr.constructor && arr.constructor.name).to.match(
+      /Float32Array|Float64Array|ArrayBuffer|Uint8Array/
+    );
+
+    // Convert to plain array if needed
+    const samples: number[] = Array.from(arr as any);
+    // Expect either note_count > 0 indirectly via nonzero samples
+    const anyNonZero = samples.some((s) => s !== 0);
+    expect(anyNonZero).to.be.true;
+  });
+});

package/tsconfig.json

@@ -52,7 +52,7 @@
     // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
 
     /* Emit */
-    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
     // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
     // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
     // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */

package/typescript/core/functions/index.ts

@@ -0,0 +1,83 @@
+import { ParseResult } from "../types/result";
+import { DebugResult } from "../types/result";
+
+let wasmPkg: any = undefined;
+try {
+  // prefer runtime pkg generated by wasm-pack when available
+  // require at runtime so the package can be used even if wasm hasn't been built
+  // (this keeps tests and consumers robust).
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  wasmPkg = require("../../pkg/devalang_core");
+} catch (_e) {
+  wasmPkg = undefined;
+}
+
+/**
+ * Parses the user code.
+ * @param entry_path The entry path for the code.
+ * @param source The source code to parse.
+ * @returns ParseResult | any
+ */
+export function parse(entry_path: string, source: string): ParseResult | any {
+  if (wasmPkg && typeof wasmPkg.parse === "function") {
+    return wasmPkg.parse(entry_path, source);
+  }
+
+  throw new Error(
+    "WASM binding 'parse' not available. Build the wasm package or use the JS runtime."
+  );
+}
+
+/**
+ * Renders the debug information for the user code.
+ * @param user_code The user-provided code to render debug information for.
+ * @returns DebugResult | any
+ */
+export function debug_render(user_code: string): DebugResult | any {
+  if (wasmPkg && typeof wasmPkg.debug_render === "function") {
+    return wasmPkg.debug_render(user_code);
+  }
+
+  throw new Error(
+    "WASM binding 'debug_render' not available. Build the wasm package or use the JS runtime."
+  );
+}
+
+/**
+ * Renders audio from the user code.
+ * @param user_code The user-provided code to render audio from.
+ * @returns Float32Array
+ */
+export function render_audio(user_code: string): Float32Array {
+  if (wasmPkg && typeof wasmPkg.render_audio === "function") {
+    return wasmPkg.render_audio(user_code);
+  }
+
+  // Fallback: indicate missing wasm with an empty buffer rather than breaking consumers.
+  return new Float32Array(0);
+}
+
+/**
+ * Register a JS callback to receive playhead events { time, line, column } during playback.
+ * The callback will be called with a single object argument.
+ * @param cb The callback function to register.
+ * @returns void
+ */
+export function register_playhead_callback(cb: (ev: { time: number; line: number; column: number }) => void) {
+  if (wasmPkg && typeof wasmPkg.register_playhead_callback === "function") {
+    return wasmPkg.register_playhead_callback(cb);
+  }
+  // no-op fallback
+  return;
+}
+
+/**
+ * Unregisters the JS callback for playhead events.
+ * @returns void
+ */
+export function unregister_playhead_callback() {
+  if (wasmPkg && typeof wasmPkg.unregister_playhead_callback === "function") {
+    return wasmPkg.unregister_playhead_callback();
+  }
+  return;
+}

package/typescript/core/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Core functionality for the Devalang language.
+ * This module exports all the core types and functions used in the language.
+ */
+export * from "./types/index";
+export * from "./functions/index";

package/typescript/core/types/index.ts

@@ -0,0 +1,4 @@
+export * from "./result";
+export * from "./statement";
+export * from "./value";
+export * from "./plugin";

package/typescript/core/types/plugin.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents a plugin export.
+ */
+export interface PluginExport {
+  name: string;
+  kind: string;
+  default?: any;
+}
+
+/**
+ * Represents a plugin.
+ */
+export interface PluginInfo {
+  author: string;
+  name: string;
+  version?: string;
+  description?: string;
+  exports: PluginExport[];
+}

package/typescript/core/types/result.ts

@@ -0,0 +1,29 @@
+/**
+ * Represents an error that occurred during parsing.
+ */
+export interface ErrorResult {
+  message: string;
+  line: number;
+  column: number;
+}
+
+/**
+ * Represents the result of parsing user code.
+ */
+export interface ParseResult {
+  ok: boolean;
+  ast: string;
+  errors: ErrorResult[];
+}
+
+/**
+ * Represents the result of debugging user code.
+ */
+export interface DebugResult {
+  samples_len: number;
+  any_nonzero: boolean;
+  ast: string;
+  note_count: number;
+  global_vars: string[];
+  statements_count: number;
+}

package/typescript/core/types/statement.ts

@@ -0,0 +1,47 @@
+import { Value, Duration } from "./value";
+
+/**
+ * Represents a statement kind in the code.
+ */
+ export type StatementKind =
+   | { kind: "Tempo" }
+   | { kind: "Bank"; alias?: string }
+   | { kind: "Print" }
+   | { kind: "Load"; source: string; alias: string }
+   | { kind: "Use"; name: string; alias?: string }
+   | { kind: "Let"; name: string }
+   | { kind: "Automate"; target: string }
+   | { kind: "ArrowCall"; target: string; method: string; args: Value[] }
+   | { kind: "Function"; name: string; parameters: string[]; body: Statement[] }
+   | { kind: "Synth" }
+   | { kind: "Trigger"; entity: string; duration: Duration; effects?: Value }
+   | { kind: "Sleep" }
+   | { kind: "Call"; name: string; args: Value[] }
+   | { kind: "Spawn"; name: string; args: Value[] }
+   | { kind: "Loop" }
+   | { kind: "Group" }
+   | { kind: "Include"; path: string }
+   | { kind: "Export"; names: string[]; source: string }
+   | { kind: "Import"; names: string[]; source: string }
+   | { kind: "If" }
+   | { kind: "Else" }
+   | { kind: "ElseIf" }
+   | { kind: "Comment" }
+   | { kind: "Indent" }
+   | { kind: "Dedent" }
+   | { kind: "NewLine" }
+   | { kind: "On"; event: string; args?: Value[]; body: Statement[] }
+   | { kind: "Emit"; event: string; payload?: Value }
+   | { kind: "Unknown" }
+   | { kind: "Error"; message: string };
+
+/**
+ * Represents a statement in the code.
+ */
+ export interface Statement {
+   kind: StatementKind;
+   value: Value;
+   indent: number;
+   line: number;
+   column: number;
+ }

package/typescript/core/types/value.ts

@@ -0,0 +1,29 @@
+import { Statement } from "./statement";
+
+/**
+ * Represents a duration in the code.
+ */
+export type Duration =
+  | { Number: number }
+  | { Identifier: string }
+  | { Beat: string }
+  | { Auto: null };
+
+/**
+ * Represents a value in the code.
+ */
+export type Value =
+  | { Boolean: boolean }
+  | { Number: number }
+  | { Duration: Duration }
+  | { Identifier: string }
+  | { String: string }
+  | { Array: Value[] }
+  | { Map: Record<string, Value> }
+  | { Block: Statement[] }
+  | { Sample: string }
+  | { Beat: string }
+  | { Statement: Statement }
+  | { StatementKind: any }
+  | { Unknown: null }
+  | null;

package/typescript/index.ts

@@ -1,3 +1,8 @@
 /**
- * TypeScript wrapper for Devalang.
- */
+ * Public TypeScript definitions for Devalang.
+ * ————————————————————————————————————————
+ * Used to provide TypeScript types for the Devalang WASM package.
+ */
+
+export * as pkg from "./pkg/devalang_core";
+export * as core from "./core/index";

package/typescript/pkg/devalang_core.d.ts

@@ -0,0 +1,4 @@
+/**
+ * This module exports all the core types and functions used in the WASM package.
+ */
+export * from "../../pkg/devalang_core";

package/typescript/scripts/copy-wasm-dts.ts

@@ -0,0 +1,41 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Copies .d.ts files from pkg/ (wasm-pack output) into out-tsc/pkg/
+const ROOT = path.resolve(__dirname, '..', '..');
+const PKG_DIR = path.join(ROOT, 'pkg');
+const OUT_DIR = path.join(ROOT, 'out-tsc', 'pkg');
+
+function ensureDir(p: string): void {
+  if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true });
+}
+
+function copyDir(src: string, dest: string): void {
+  ensureDir(dest);
+  const items = fs.readdirSync(src, { withFileTypes: true });
+  for (const item of items) {
+    const srcPath = path.join(src, item.name);
+    const destPath = path.join(dest, item.name);
+    if (item.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else if (item.isFile() && item.name.endsWith('.d.ts')) {
+      fs.copyFileSync(srcPath, destPath);
+      console.log('copied', srcPath, '->', destPath);
+    }
+  }
+}
+
+function main(): number {
+  if (!fs.existsSync(PKG_DIR)) {
+    console.error('pkg directory not found at', PKG_DIR);
+    return 1;
+  }
+
+  ensureDir(OUT_DIR);
+  copyDir(PKG_DIR, OUT_DIR);
+  console.log('done');
+  return 0;
+}
+
+const exitCode = main();
+if (exitCode !== 0) process.exit(exitCode);