@teurons/vds 0.0.0-stage → 0.0.1

package/dist/vds.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+// src/bin.js
+import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { join, resolve } from "node:path";
+
+// ../../specs/js/load.js
+import { readFileSync } from "node:fs";
+var compiled = /* @__PURE__ */ new Map();
+function compile(url, build) {
+  const key = String(url);
+  if (!compiled.has(key)) {
+    let bytes;
+    try {
+      bytes = readFileSync(url);
+    } catch {
+      throw new Error(`${key.split("/").pop()} is missing. Build it with: ${build}`);
+    }
+    compiled.set(key, new WebAssembly.Module(bytes));
+  }
+  return compiled.get(key);
+}
+
+// ../../specs/js/bridge.js
+var enc = new TextEncoder();
+var dec = new TextDecoder();
+function instanceOf(module) {
+  return new WebAssembly.Instance(module, {});
+}
+function bridge(instance) {
+  const x = instance.exports;
+  const read = (packed) => {
+    const ptr = Number(packed >> 32n);
+    const len = Number(packed & 0xffffffffn);
+    const text = dec.decode(new Uint8Array(x.memory.buffer, ptr, len));
+    x.dealloc(ptr, len);
+    return text;
+  };
+  const call = (fn, input) => {
+    const bytes = enc.encode(input);
+    const ptr = x.alloc(bytes.length);
+    new Uint8Array(x.memory.buffer, ptr, bytes.length).set(bytes);
+    return read(x[fn](ptr, bytes.length));
+  };
+  return {
+    call,
+    /** Calls an export with a value as JSON and returns its answer parsed. */
+    json: (fn, input) => JSON.parse(call(fn, JSON.stringify(input))),
+    /** Calls an export that takes nothing and returns its answer parsed. */
+    none: (fn) => JSON.parse(read(x[fn]()))
+  };
+}
+
+// ../../mapper/js/index.js
+function bind(instance) {
+  const { call, json } = bridge(instance);
+  return {
+    validate: (files) => json("validate", files),
+    v2Check: (files) => json("v2_check", files),
+    v2Index: (files) => call("v2_index", JSON.stringify(files)),
+    load: (files) => json("load", files),
+    check: (changes) => json("check", changes),
+    apply: (changes) => json("apply", changes),
+    toYaml: (doc) => call("to_yaml", typeof doc === "string" ? doc : JSON.stringify(doc)),
+    toYamlOver: (original, doc) => call("to_yaml_over", JSON.stringify({ original, doc })),
+    parseYaml: (text) => {
+      const r = JSON.parse(call("parse_yaml", text));
+      if ("error" in r) throw new Error(r.error);
+      return r.ok;
+    },
+    nextId: (kind, parent) => json("next_id", { kind, parent: parent ?? null }).id ?? null,
+    readSettings: (text) => json("read_settings", { settings: text ?? null }),
+    workspaceFiles: (paths) => json("workspace_files", paths),
+    classify: (files) => json("classify", files),
+    pathOf: (input) => json("path_of", input).path,
+    describe: (settings, path) => json("path_of", { settings: settings ?? null, of: "describe", path }),
+    parseFeature: (text) => JSON.parse(call("parse_feature", text)),
+    writeFeature: (input) => call("write_feature", JSON.stringify(input)),
+    retitleFeature: (text, requirement, title) => call("retitle_feature", JSON.stringify({ text, requirement, title })),
+    putScenario: (text, scenario) => call("put_scenario", JSON.stringify({ text, scenario })),
+    removeScenario: (text, id) => call("remove_scenario", JSON.stringify({ text, id }))
+  };
+}
+function instantiate(module) {
+  return bind(instanceOf(module));
+}
+
+// ../../mapper/js/node.js
+function mapperModule() {
+  return compile(new URL("./vds_mapper.wasm", import.meta.url), "pnpm --filter @vds/mapper build");
+}
+function loadMapper() {
+  return instantiate(mapperModule());
+}
+
+// src/bin.js
+var FOLDERS = ["capabilities", "flows", "scenarios"];
+function readWorkspace(root) {
+  const files = {};
+  for (const dir of FOLDERS) {
+    let names = [];
+    try {
+      names = readdirSync(join(root, dir));
+    } catch {
+      continue;
+    }
+    for (const name of names) files[`${dir}/${name}`] = readFileSync2(join(root, dir, name), "utf8");
+  }
+  return files;
+}
+async function main([command, folder = "."]) {
+  const mapper = await loadMapper();
+  const files = readWorkspace(resolve(folder));
+  if (command === "check") {
+    const findings = mapper.v2Check(files);
+    if ("error" in findings) throw new Error(findings.error);
+    if (findings.length === 0) {
+      console.log("valid");
+      return 0;
+    }
+    console.error(`${findings.length} problem(s):`);
+    for (const f of findings) console.error(`- ${f.path}: ${f.message} [${f.code}]`);
+    return 1;
+  }
+  if (command === "index") {
+    process.stdout.write(mapper.v2Index(files));
+    return 0;
+  }
+  console.error("usage: vds check [folder] | vds index [folder]");
+  return 2;
+}
+process.exitCode = await main(process.argv.slice(2));

package/package.json

@@ -1,6 +1,36 @@
 {
   "name": "@teurons/vds",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1",
+  "description": "The vds command: check, index and run a VDS workspace on your machine.",
+  "type": "module",
+  "bin": {
+    "vds": "dist/vds.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "node build.mjs",
+    "test": "vitest run",
+    "prepack": "node build.mjs",
+    "release": "node release.mjs"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@vds/mapper": "workspace:*",
+    "esbuild": "0.28.1",
+    "vitest": "5.0.1"
+  },
+  "license": "UNLICENSED",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/teurons/vds.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.