@vsirotin/ts-stop 1.12.1 → 1.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vsirotin/ts-stop",
-  "version": "1.12.1",
+  "version": "1.13.1",
   "description": "State Oriented Programming library for TypeScript",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -20,10 +20,21 @@
   },
   "files": [
     "lib",
+    "scripts/reduce-fa.js",
+    "scripts/merge-fas.js",
+    "scripts/merge-fas-from-dir.js",
+    "scripts/update-fa.js",
     "README.md",
     "LICENSE",
     "LICENSE-COMMERCIAL.md"
   ],
+  "bin": {
+    "reduce-fa": "./scripts/reduce-fa.js",
+    "merge-fas": "./scripts/merge-fas.js",
+    "merge-fas-from-dir": "./scripts/merge-fas-from-dir.js",
+    "update-full-fa": "./scripts/update-fa.js",
+    "update-compact-fa": "./scripts/update-fa.js"
+  },
   "scripts": {
     "build": "npm run build:cjs && npm run build:esm",
     "build:cjs": "tsc",
@@ -31,10 +42,10 @@
     "test": "jest",
     "test:coverage": "jest --coverage",
     "clean": "rm -rf lib coverage",
-    "publish:local": "./scripts/publish-local.sh",
     "pack": "npm run build && npm pack",
     "reduce-fa": "node scripts/reduce-fa.js",
     "merge-fas": "node scripts/merge-fas.js",
+    "merge-fas-from-dir": "node scripts/merge-fas-from-dir.js",
     "update-full-fa": "node scripts/update-fa.js --format=full",
     "update-compact-fa": "node scripts/update-fa.js --format=compact"
   },

package/scripts/merge-fas-from-dir.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * merge-fas-from-dir.js — CLI tool to recursively merge all FA JSON files from a directory.
+ *
+ * Usage:
+ *   node scripts/merge-fas-from-dir.js --input-dir=<path/to/dir> --result=<path/to/result.json>
+ *
+ * Behavior:
+ * - Recursively finds all .json files in the input directory (including subdirectories).
+ * - Sorts files alphabetically by full path for consistent merge order.
+ * - Each input file is reduced with reduceFA semantics.
+ * - Already compact files are used unchanged.
+ * - Duplicate FA keys are overwritten by the latest file and reported as warnings.
+ * - Output is a single merged compact FA definition.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { mergeFAs } = require('../lib/sfsm');
+
+const args = process.argv.slice(2);
+const options = {};
+
+for (const arg of args) {
+    const match = arg.match(/^--([^=]+)=(.+)$/);
+    if (match) {
+        options[match[1]] = match[2];
+    }
+}
+
+if (!options['input-dir']) {
+    console.error('Error: --input-dir=<path> is required.');
+    console.error('Usage: node scripts/merge-fas-from-dir.js --input-dir=<path/to/dir> --result=<path/to/result.json>');
+    process.exit(1);
+}
+
+if (!options.result) {
+    console.error('Error: --result=<path> is required.');
+    console.error('Usage: node scripts/merge-fas-from-dir.js --input-dir=<path/to/dir> --result=<path/to/result.json>');
+    process.exit(1);
+}
+
+const inputDir = path.resolve(process.cwd(), options['input-dir']);
+const resultFile = path.resolve(process.cwd(), options.result);
+
+// Verify input directory exists
+if (!fs.existsSync(inputDir) || !fs.statSync(inputDir).isDirectory()) {
+    console.error(`Error: Input directory not found or not a directory: ${inputDir}`);
+    process.exit(1);
+}
+
+/**
+ * Recursively find all .json files in a directory.
+ */
+function findJsonFiles(dir, baseDir = dir) {
+    const files = [];
+    const entries = fs.readdirSync(dir);
+
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        const stat = fs.statSync(fullPath);
+
+        if (stat.isDirectory()) {
+            files.push(...findJsonFiles(fullPath, baseDir));
+        } else if (entry.endsWith('.json')) {
+            files.push(fullPath);
+        }
+    }
+
+    return files;
+}
+
+/**
+ * Check if a definition is in compact format.
+ */
+function isCompactDefinition(definition) {
+    const entries = Object.entries(definition);
+    return entries.length > 0 && entries.every(([, value]) => Array.isArray(value));
+}
+
+// Find all JSON files
+const jsonFiles = findJsonFiles(inputDir).sort();
+
+if (jsonFiles.length === 0) {
+    console.error(`Error: No JSON files found in input directory: ${inputDir}`);
+    process.exit(1);
+}
+
+console.log(`Found ${jsonFiles.length} JSON file(s) in ${inputDir}`);
+
+const definitions = [];
+
+for (let i = 0; i < jsonFiles.length; i++) {
+    const file = jsonFiles[i];
+    const relPath = path.relative(inputDir, file);
+    let definition;
+
+    try {
+        definition = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    } catch (err) {
+        console.error(`Error: Failed to parse JSON from ${file}: ${err.message}`);
+        process.exit(1);
+    }
+
+    if (isCompactDefinition(definition)) {
+        console.log(`Info: Input #${i + 1} is already compact and will be used as-is: ${relPath}`);
+    } else {
+        console.log(`Info: Input #${i + 1} is extended and will be reduced: ${relPath}`);
+    }
+
+    definitions.push(definition);
+}
+
+const { merged, warnings } = mergeFAs(definitions);
+
+for (const warning of warnings) {
+    console.warn(`Warning: ${warning}`);
+}
+
+const json = JSON.stringify(merged, null, 4).replace(
+    /\[\s*\n\s*"([^"]+)",\s*\n\s*"([^"]+)",\s*\n\s*"([^"]+)"(?:,\s*\n\s*"([^"]+)")?\s*\n\s*\]/g,
+    (_, a, b, c, d) => d ? `["${a}", "${b}", "${c}", "${d}"]` : `["${a}", "${b}", "${c}"]`
+);
+
+fs.mkdirSync(path.dirname(resultFile), { recursive: true });
+fs.writeFileSync(resultFile, `${json}\n`, 'utf-8');
+console.log(`Merged compact FA written to: ${resultFile}`);

package/scripts/merge-fas.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * merge-fas.js — CLI tool to reduce and merge multiple FA JSON files.
+ *
+ * Usage:
+ *   npm run merge-fas -- --result=<path/to/result.json> <file1[,file2,...]> [file3 ...]
+ *
+ * Behavior:
+ * - Each input file is reduced with reduceFA semantics.
+ * - Already compact files are used unchanged.
+ * - Duplicate FA keys are overwritten by the latest file and reported as warnings.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { mergeFAs } = require('../lib/sfsm');
+
+const args = process.argv.slice(2);
+const options = {};
+const rawFiles = [];
+
+for (const arg of args) {
+    const match = arg.match(/^--([^=]+)=(.+)$/);
+    if (match) {
+        options[match[1]] = match[2];
+    } else {
+        rawFiles.push(arg);
+    }
+}
+
+if (!options.result) {
+    console.error('Error: --result=<path> is required.');
+    console.error('Usage: npm run merge-fas -- --result=<path/to/result.json> <file1[,file2,...]> [file3 ...]');
+    process.exit(1);
+}
+
+const inputFiles = rawFiles
+    .flatMap((chunk) => chunk.split(','))
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+if (inputFiles.length === 0) {
+    console.error('Error: At least one input file is required.');
+    console.error('Usage: npm run merge-fas -- --result=<path/to/result.json> <file1[,file2,...]> [file3 ...]');
+    process.exit(1);
+}
+
+const resolvedInputFiles = inputFiles.map((f) => path.resolve(process.cwd(), f));
+const resultFile = path.resolve(process.cwd(), options.result);
+
+for (const file of resolvedInputFiles) {
+    if (!fs.existsSync(file)) {
+        console.error(`Error: Input file not found: ${file}`);
+        process.exit(1);
+    }
+}
+
+function isCompactDefinition(definition) {
+    const entries = Object.entries(definition);
+    return entries.length > 0 && entries.every(([, value]) => Array.isArray(value));
+}
+
+const definitions = [];
+
+for (let i = 0; i < resolvedInputFiles.length; i++) {
+    const file = resolvedInputFiles[i];
+    let definition;
+    try {
+        definition = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    } catch (err) {
+        console.error(`Error: Failed to parse JSON from ${file}: ${err.message}`);
+        process.exit(1);
+    }
+
+    if (isCompactDefinition(definition)) {
+        console.log(`Info: Input #${i + 1} is already compact and will be used as-is: ${file}`);
+    } else {
+        console.log(`Info: Input #${i + 1} is extended and will be reduced: ${file}`);
+    }
+
+    definitions.push(definition);
+}
+
+const { merged, warnings } = mergeFAs(definitions);
+
+for (const warning of warnings) {
+    console.warn(`Warning: ${warning}`);
+}
+
+const json = JSON.stringify(merged, null, 4).replace(
+    /\[\s*\n\s*"([^"]+)",\s*\n\s*"([^"]+)",\s*\n\s*"([^"]+)"(?:,\s*\n\s*"([^"]+)")?\s*\n\s*\]/g,
+    (_, a, b, c, d) => d ? `["${a}", "${b}", "${c}", "${d}"]` : `["${a}", "${b}", "${c}"]`
+);
+
+fs.mkdirSync(path.dirname(resultFile), { recursive: true });
+fs.writeFileSync(resultFile, `${json}\n`, 'utf-8');
+console.log(`Merged compact FA written to: ${resultFile}`);

package/scripts/reduce-fa.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * reduce-fa.js — CLI tool to convert an extended FA JSON file to compact format.
+ *
+ * Usage:
+ *   npm run reduce-fa -- <path/to/extended-fa.json>
+ *
+ * Output:
+ *   Writes the compact definition to <input>-compact.json in the same directory.
+ *
+ * Requires the library to be built first: npm run build
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { reduceFA } = require('../lib/sfsm');
+
+const inputArg = process.argv[2];
+
+if (!inputArg) {
+    console.error('Error: No input file specified.');
+    console.error('Usage: npm run reduce-fa -- <path/to/extended-fa.json>');
+    process.exit(1);
+}
+
+const inputFile = path.resolve(process.cwd(), inputArg);
+
+if (!fs.existsSync(inputFile)) {
+    console.error(`Error: File not found: ${inputFile}`);
+    process.exit(1);
+}
+
+let definition;
+try {
+    definition = JSON.parse(fs.readFileSync(inputFile, 'utf-8'));
+} catch (err) {
+    console.error(`Error: Failed to parse JSON from ${inputFile}: ${err.message}`);
+    process.exit(1);
+}
+
+const compact = reduceFA(definition);
+
+const ext = path.extname(inputFile);
+const base = path.basename(inputFile, ext);
+const dir = path.dirname(inputFile);
+const outputFile = path.join(dir, `${base}-compact${ext}`);
+
+// Serialize with transitions inline: ["state", "signal", "newState", "cmd?"]
+const json = JSON.stringify(compact, null, 4).replace(
+    /\[\s*\n\s*"([^"]+)",\s*\n\s*"([^"]+)",\s*\n\s*"([^"]+)"(?:,\s*\n\s*"([^"]+)")?\s*\n\s*\]/g,
+    (_, a, b, c, d) => d ? `["${a}", "${b}", "${c}", "${d}"]` : `["${a}", "${b}", "${c}"]`
+);
+fs.writeFileSync(outputFile, json, 'utf-8');
+console.log(`Reduced FA written to: ${outputFile}`);

package/scripts/update-fa.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * update-fa.js — CLI tool to apply an FA update file to a source FA JSON file.
+ *
+ * Invoked via npm scripts:
+ *   npm run update-full-fa    -- --source=<path> --update=<path> [--result=<path>]
+ *   npm run update-compact-fa -- --source=<path> --update=<path> [--result=<path>]
+ *
+ * If --result is omitted, the output file is named <source-basename>-updated.json.
+ *
+ * Requires the library to be built first: npm run build
+ */
+
+const fs   = require('fs');
+const path = require('path');
+const { updateFullFA, updateCompactFA } = require('../lib/sfsm');
+
+// ---------------------------------------------------------------------------
+// Parse args
+// ---------------------------------------------------------------------------
+
+const args = {};
+for (const arg of process.argv.slice(2)) {
+    const match = arg.match(/^--([^=]+)=(.+)$/);
+    if (match) args[match[1]] = match[2];
+}
+
+const format = args['format'];
+if (!format || !['full', 'compact'].includes(format)) {
+    console.error('Error: --format=full|compact is required (set by the npm script).');
+    process.exit(1);
+}
+
+if (!args['source']) {
+    console.error('Error: --source=<path> is required.');
+    console.error(`Usage: npm run update-${format}-fa -- --source=<path> --update=<path> [--result=<path>]`);
+    process.exit(1);
+}
+
+if (!args['update']) {
+    console.error('Error: --update=<path> is required.');
+    console.error(`Usage: npm run update-${format}-fa -- --source=<path> --update=<path> [--result=<path>]`);
+    process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Resolve paths
+// ---------------------------------------------------------------------------
+
+const sourceFile = path.resolve(process.cwd(), args['source']);
+const updateFile = path.resolve(process.cwd(), args['update']);
+
+let resultFile;
+if (args['result']) {
+    resultFile = path.resolve(process.cwd(), args['result']);
+} else {
+    const ext  = path.extname(sourceFile);
+    const base = path.basename(sourceFile, ext);
+    const dir  = path.dirname(sourceFile);
+    resultFile = path.join(dir, `${base}-updated${ext}`);
+}
+
+// ---------------------------------------------------------------------------
+// Load & validate
+// ---------------------------------------------------------------------------
+
+if (!fs.existsSync(sourceFile)) {
+    console.error(`Error: Source file not found: ${sourceFile}`);
+    process.exit(1);
+}
+
+if (!fs.existsSync(updateFile)) {
+    console.error(`Error: Update file not found: ${updateFile}`);
+    process.exit(1);
+}
+
+let source, update;
+try {
+    source = JSON.parse(fs.readFileSync(sourceFile, 'utf-8'));
+} catch (err) {
+    console.error(`Error: Failed to parse source JSON: ${err.message}`);
+    process.exit(1);
+}
+
+try {
+    update = JSON.parse(fs.readFileSync(updateFile, 'utf-8'));
+} catch (err) {
+    console.error(`Error: Failed to parse update JSON: ${err.message}`);
+    process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Apply update
+// ---------------------------------------------------------------------------
+
+let result;
+try {
+    result = format === 'full'
+        ? updateFullFA(source, update)
+        : updateCompactFA(source, update);
+} catch (err) {
+    console.error(`Error: Update failed: ${err.message}`);
+    process.exit(1);
+}
+
+fs.writeFileSync(resultFile, JSON.stringify(result, null, 4), 'utf-8');
+console.log(`Updated FA written to: ${resultFile}`);