@microtronics/studio-cli 0.27.3 → 0.29.0

package/out/dlo/CustomWasmFS.js

@@ -0,0 +1,227 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUSTOM_WASM_FS = exports.precompilerDiagnostics = void 0;
+exports.uriToMemFsPath = uriToMemFsPath;
+const nodeFs = __importStar(require("fs"));
+const vscode_uri_1 = require("vscode-uri");
+const preCompiler_1 = require("./preCompiler");
+const helper_1 = require("../helper");
+var convertBlobToStringArray = helper_1.Helper.convertBlobToStringArray;
+const iconv = __importStar(require("iconv-lite"));
+const S_IFDIR = 0o040000; // Directory flag
+const DEFAULT_DIR_MODE = 0o777; // rwxrwxrwx
+const MODE_DIR = S_IFDIR | DEFAULT_DIR_MODE;
+const S_IFREG = 0o100000; // Regular file flag
+const DEFAULT_FILE_MODE = 0o666; // rw-rw-rw-
+const MODE_FILE = S_IFREG | DEFAULT_FILE_MODE;
+const preCompiler = new preCompiler_1.DloPreCompiler();
+const modifiedFileCache = {};
+exports.precompilerDiagnostics = [];
+const CUSTOM_WASM_FS = (FS, cwd, manifest) => {
+    // clear all cached artifacts during FS setup ( this is needed when loaded in vscode context )
+    exports.precompilerDiagnostics.length = 0;
+    Object.keys(modifiedFileCache).forEach(key => delete modifiedFileCache[key]);
+    const nodeOps = {
+        getattr(node) {
+            const path = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(node.mount.opts.root), FS.getPath(node));
+            const fsPath = path.fsPath;
+            if (!nodeFs.existsSync(fsPath)) {
+                throw new FS.ErrnoError(44 /* ENOENT */);
+            }
+            const modifiedFileContent = getUpdateModifiedFileCache(cwd, manifest, path);
+            const stat = nodeFs.statSync(fsPath);
+            const size = modifiedFileContent?.length || stat.size;
+            return {
+                mode: stat.isDirectory() ? MODE_DIR : MODE_FILE,
+                size: size,
+                atime: stat.atime,
+                mtime: stat.mtime,
+                ctime: stat.ctime
+            };
+        },
+        lookup(parent, name) {
+            const currPath = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(parent.mount.opts.root), FS.getPath(parent), name);
+            const path = currPath.fsPath;
+            if (!nodeFs.existsSync(path)) {
+                throw new FS.ErrnoError(44 /* ENOENT */);
+            }
+            const stat = nodeFs.statSync(path);
+            const node = FS.createNode(parent, name, stat.isDirectory() ? MODE_DIR : MODE_FILE, 0);
+            node.node_ops = parent.node_ops;
+            node.stream_ops = parent.stream_ops;
+            return node;
+        },
+        readdir(node) {
+            const path = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(node.mount.opts.root), FS.getPath(node)).fsPath;
+            return ['.', '..', ...nodeFs.readdirSync(path)];
+        },
+        mknod(parent, name, mode, dev) {
+            const path = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(parent.mount.opts.root), FS.getPath(parent), name).fsPath;
+            nodeFs.writeFileSync(path, '');
+            return FS.createNode(parent, name, mode, dev);
+        },
+        unlink(parent, name) {
+            const path = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(parent.mount.opts.root), FS.getPath(parent), name).fsPath;
+            nodeFs.unlinkSync(path);
+        },
+        mkdir(parent, name, mode) {
+            const path = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(parent.mount.opts.root), FS.getPath(parent), name).fsPath;
+            nodeFs.mkdirSync(path, { mode });
+            return FS.createNode(parent, name, mode | MODE_DIR, 0);
+        },
+        rmdir(parent, name) {
+            const path = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(parent.mount.opts.root), FS.getPath(parent), name).fsPath;
+            nodeFs.rmdirSync(path);
+        },
+        rename(oldParent, oldName, newParent, newName) {
+            const oldPath = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(oldParent.mount.opts.root), FS.getPath(oldParent), oldName).fsPath;
+            const newPath = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(newParent.mount.opts.root), FS.getPath(newParent), newName).fsPath;
+            nodeFs.renameSync(oldPath, newPath);
+        }
+    };
+    const streamOps = {
+        open(stream) {
+            const path = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.parse(stream.node.mount.opts.root), FS.getPath(stream.node));
+            stream.modifiedContent = getUpdateModifiedFileCache(cwd, manifest, path);
+            if (!stream.modifiedContent) {
+                stream.nfd = nodeFs.openSync(path.fsPath, flagsToMode(stream.flags));
+            }
+        },
+        close(stream) {
+            if (stream.nfd) {
+                nodeFs.closeSync(stream.nfd);
+            }
+        },
+        read(stream, buffer, offset, length, position) {
+            // allow reading none precompiled files
+            if (!stream.modifiedContent) {
+                return nodeFs.readSync(stream.nfd, buffer, offset, length, position);
+            }
+            const fileContent = stream.modifiedContent;
+            if (position >= fileContent.length) {
+                return 0;
+            } // EOF handling properly
+            const bytesAvailable = fileContent.length - position;
+            const bytesToRead = Math.min(length, bytesAvailable);
+            copyToBuffer(fileContent, buffer, offset, position, position + bytesToRead);
+            // fileContent.copy(buffer, offset, position, position + bytesToRead);
+            return bytesToRead;
+        },
+        write(stream, buffer, offset, length, position) {
+            return nodeFs.writeSync(stream.nfd, buffer, offset, length, position);
+        },
+        flagsToMode: flagsToMode,
+        llseek(stream, offset, whence) {
+            let position = offset;
+            if (whence === 1) {
+                position += stream.position;
+            }
+            else if (whence === 2) {
+                const stat = nodeFs.fstatSync(stream.nfd);
+                position += stat.size;
+            }
+            if (position < 0) {
+                throw new FS.ErrnoError(28);
+            } // EINVAL
+            stream.position = position;
+            return position;
+        }
+    };
+    return {
+        mount( /*mount: any*/) {
+            const memfsRoot = uriToMemFsPath(cwd);
+            const root = FS.createNode(null, memfsRoot, S_IFDIR | DEFAULT_DIR_MODE, 0);
+            root.node_ops = nodeOps;
+            root.stream_ops = streamOps;
+            return root;
+        },
+        node_ops: nodeOps,
+        stream_ops: streamOps
+    };
+};
+exports.CUSTOM_WASM_FS = CUSTOM_WASM_FS;
+function flagsToMode(flags) {
+    const accmode = flags & 2097155;
+    if (accmode === 0)
+        return 'r';
+    if (accmode === 1)
+        return 'r+';
+    if (accmode === 65)
+        return 'w';
+    if (accmode === 577)
+        return 'w+';
+    if (accmode === 1089)
+        return 'a';
+    if (accmode === 1217)
+        return 'a+';
+    throw new Error(`Unknown file open flags: ${flags}`);
+}
+/**
+ * Copies a segment of data from the source buffer to the target buffer, starting at specified offsets.
+ * Somehow within the vscode context the target buffer is an Int8Array.
+ *
+ * @param {Buffer | Uint8Array} source The buffer or Uint8Array to copy data from.
+ * @param {Buffer | Uint8Array | Int8Array} target The buffer, Uint8Array, or Int8Array to copy data into.
+ * @param {number} targetOffset The offset in the target buffer where data should begin being placed.
+ * @param {number} sourceStart The starting index in the source buffer to begin copying from.
+ * @param {number} sourceEnd The ending index (exclusive) in the source buffer to stop copying.
+ * @return {void} Does not return a value. The target buffer is modified in place.
+ */
+function copyToBuffer(source, target, targetOffset, sourceStart, sourceEnd) {
+    if (Buffer.isBuffer(source) && Buffer.isBuffer(target)) {
+        source.copy(target, targetOffset, sourceStart, sourceEnd);
+    }
+    else {
+        const slicedSource = source.subarray(sourceStart, sourceEnd);
+        if (Buffer.isBuffer(target)) {
+            // Source is Uint8Array, target is Buffer
+            Uint8Array.prototype.set.call(target, slicedSource, targetOffset);
+        }
+        else {
+            // Handles Uint8Array and Int8Array or other TypedArrays safely
+            target.set(slicedSource, targetOffset);
+        }
+    }
+}
+function getUpdateModifiedFileCache(cwd, manifest, filePath) {
+    const fsPath = filePath.fsPath;
+    if (!modifiedFileCache[fsPath] && (fsPath.endsWith('.dlo') || fsPath.endsWith('.inc'))) {
+        modifiedFileCache[fsPath] = precompileRequestedDloFile(cwd, manifest, filePath);
+    }
+    return modifiedFileCache[fsPath];
+}
+function precompileRequestedDloFile(cwd, manifest, filePath) {
+    // Simple example: convert buffer content to a string, modify and convert back
+    const originalContent = nodeFs.readFileSync(filePath.fsPath);
+    const fileBlob = convertBlobToStringArray(originalContent);
+    const preCompiled = preCompiler.preCompileDloFile(cwd, manifest, filePath, fileBlob);
+    exports.precompilerDiagnostics.push(...preCompiled.diagnostics);
+    return iconv.encode(preCompiled.data, 'cp1252');
+}
+function uriToMemFsPath(path) {
+    return path.fsPath.replace(/\\/g, '/');
+}
+//# sourceMappingURL=CustomWasmFS.js.map

package/out/dlo/compiler.js

@@ -24,7 +24,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DloCompiler = void 0;
-exports.uriToMemFsPath = uriToMemFsPath;
 exports.parseWarningsAndErrors = parseWarningsAndErrors;
 exports.generateConfigFile = generateConfigFile;
 const preCompiler_1 = require("./preCompiler");
@@ -33,17 +32,20 @@ const manifest_1 = require("../manifest");
 const defaultFiles_1 = require("../defaultFiles");
 const dependencies_1 = require("../dependencies");
 const iconv = __importStar(require("iconv-lite"));
-const helper_1 = require("../helper");
-var convertBlobToStringArray = helper_1.Helper.convertBlobToStringArray;
 const apm_1 = require("../package/apm");
+const CustomWasmFS_1 = require("./CustomWasmFS");
 const DLO_MODULE = require('./dlocc.js');
 class DloCompiler {
+    cwd;
+    fs;
     logger;
     preCompiler = new preCompiler_1.DloPreCompiler();
     dloCC;
     stdout = [];
     stderr = [];
-    constructor(logger) {
+    constructor(cwd, fs, logger) {
+        this.cwd = cwd;
+        this.fs = fs;
         this.logger = logger;
         this.dloCC = null;
     }
@@ -57,11 +59,25 @@ class DloCompiler {
                 this.stdout.push(data);
             },
             printErr: (err) => {
-                this.logger.error(err);
+                // filter for warn messages
+                if (err.includes(': warning')) {
+                    this.logger.warn(err);
+                }
+                else {
+                    this.logger.error(err);
+                }
                 this.stderr.push(err);
                 this.stdout.push(err);
             }
         });
+        const currentCWD = (0, CustomWasmFS_1.uriToMemFsPath)(this.cwd);
+        const [rootDir] = currentCWD.split('/');
+        const FS = this.dloCC.FS;
+        const manifest = await manifest_1.Manifest.read(this.cwd, this.fs);
+        // Register our new FS type under a name
+        FS.filesystems.NODEFS_TS = (0, CustomWasmFS_1.CUSTOM_WASM_FS)(FS, this.cwd, manifest);
+        FS.mkdir(rootDir);
+        FS.mount(FS.filesystems.NODEFS_TS, { root: '/' }, rootDir);
     }
     get MEMFS() {
         return this.dloCC.FS;
@@ -69,7 +85,7 @@ class DloCompiler {
     async compile(cwd, fs) {
         const manifest = await manifest_1.Manifest.read(cwd, fs);
         if (!(await manifest_1.Manifest.isApmPartEnabled(cwd, fs, apm_1.APM.Part.dlo, manifest))) {
-            console.log('DLO not enabled. Skipped.');
+            this.logger.log('DLO not enabled. Skipped.');
             return {
                 code: 0,
                 stdout: [],
@@ -78,31 +94,27 @@ class DloCompiler {
             };
         }
         await this.initDloCC();
-        const precompilerDiagnostics = await this.persistDloFiles(cwd, fs, manifest);
         const mainFile = vscode_uri_1.Utils.joinPath(cwd, manifest.dlo?.mainFile || defaultFiles_1.DefaultFiles.filePaths.dlo.mainDLO);
         const options = [];
-        // todo only add cfg file to options if not already set!
+        // read config file
         const configFilePath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.cfg);
-        options.push(...(await this.readConfigFile(fs, configFilePath)));
-        if (this.preCompiler.pragmaDynamicFlag) {
-            options.push(this.preCompiler.pragmaDynamicFlag);
-        }
+        options.push(`-T${(0, CustomWasmFS_1.uriToMemFsPath)(configFilePath)}`);
         let exitCode = 0;
         try {
-            exitCode = await this.dloCC.callMain([uriToMemFsPath(mainFile), ...options]);
+            exitCode = await this.dloCC.callMain([(0, CustomWasmFS_1.uriToMemFsPath)(mainFile), ...options]);
             // compiler doesn't have any errors
             if (exitCode === 0) {
                 await this.persistGeneratedFiles(cwd, fs, mainFile);
             }
         }
         catch (e) {
-            console.error(e);
+            this.logger.error(e);
         }
         return {
             code: exitCode,
             stdout: this.stdout,
             stderr: this.stderr,
-            diagnostics: [...precompilerDiagnostics, ...parseWarningsAndErrors(this.stderr, mainFile)]
+            diagnostics: [...CustomWasmFS_1.precompilerDiagnostics, ...parseWarningsAndErrors(this.stderr, mainFile)]
         };
     }
     async persistGeneratedFiles(cwd, fs, mainFile) {
@@ -116,15 +128,6 @@ class DloCompiler {
             }
         }
     }
-    async readConfigFile(fs, configPath) {
-        if (await fs.stat(configPath)) {
-            const content = await fs.readFile(configPath);
-            return convertBlobToStringArray(content);
-        }
-        else {
-            return [];
-        }
-    }
     /**
      * Search for all dlo files and persist it to the MEMFS
      * @param cwd
@@ -132,9 +135,9 @@ class DloCompiler {
      * @param manifest
      * @private
      */
-    async persistDloFiles(cwd, fs, manifest) {
-        const files = await fs.findFiles(cwd, '**/*.{dlo,inc}');
-        const precompilerDiagnostics = [];
+    /*	private async persistDloFiles(cwd: URI, fs: LocalFS, manifest: Manifest.Manifest) {
+        const files = await fs.findFiles(cwd, '**!/!*.{dlo,inc}');
+        const precompilerDiagnostics: Diagnostics.File[] = [];
         // add dlo.cfg file to the file list
         for (const file of files) {
             if (await fs.stat(file)) {
@@ -145,7 +148,7 @@ class DloCompiler {
             }
         }
         return precompilerDiagnostics;
-    }
+    }*/
     /**
      * Precompile the given file and pass it to the MEMFS
      * @param cwd
@@ -158,7 +161,7 @@ class DloCompiler {
         const preCompiled = this.preCompiler.preCompileDloFile(cwd, manifest, file, stringBlob);
         precompilerDiagnostics.push(...preCompiled.diagnostics);
         this.memFSmkdir(file);
-        this.MEMFS.writeFile(uriToMemFsPath(file), iconv.encode(preCompiled.data, 'cp1252'));
+        this.MEMFS.writeFile((0, CustomWasmFS_1.uriToMemFsPath)(file), iconv.encode(preCompiled.data, 'cp1252'));
         return precompilerDiagnostics;
     }
     /**
@@ -169,10 +172,10 @@ class DloCompiler {
     async memFSmove(oldUri, newUri) {
         try {
             this.memFSmkdir(newUri);
-            this.MEMFS.rename(uriToMemFsPath(oldUri), uriToMemFsPath(newUri));
+            this.MEMFS.rename((0, CustomWasmFS_1.uriToMemFsPath)(oldUri), (0, CustomWasmFS_1.uriToMemFsPath)(newUri));
         }
         catch (e) {
-            console.error('memFSmove', e);
+            this.logger.error('memFSmove', e);
         }
     }
     /**
@@ -181,14 +184,14 @@ class DloCompiler {
      */
     async memFSunlink(uri) {
         try {
-            this.MEMFS.unlink(uriToMemFsPath(uri));
+            this.MEMFS.unlink((0, CustomWasmFS_1.uriToMemFsPath)(uri));
         }
         catch (e) {
-            console.error('memFSunlink', e);
+            this.logger.error('memFSunlink', e);
         }
     }
     memFSmkdir(uri) {
-        const split = uriToMemFsPath(vscode_uri_1.Utils.dirname(uri)).split('/');
+        const split = (0, CustomWasmFS_1.uriToMemFsPath)(vscode_uri_1.Utils.dirname(uri)).split('/');
         let dirname = '';
         split.forEach(folder => {
             if (!folder) {
@@ -201,7 +204,7 @@ class DloCompiler {
                 }
             }
             catch (e) {
-                console.error('memFSmkdir', e);
+                this.logger.error('memFSmkdir', e);
             }
         });
     }
@@ -250,9 +253,6 @@ class DloCompiler {
     }
 }
 exports.DloCompiler = DloCompiler;
-function uriToMemFsPath(path) {
-    return path.fsPath.replace(/\\/g, '/');
-}
 function parseWarningsAndErrors(stderr, relatedFile) {
     const compilerDiagnostics = [];
     const messages = stderr.filter(line => !!line.trim());
@@ -307,11 +307,11 @@ async function generateConfigFile(cwd, fs, manifest) {
         '-v2' // verbosity of stdout -> 0=quiet, 1=normal, 2=code/data/stack usage report
     ];
     const defaultIncPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.defaultInc);
-    compileOptions.push(`-p${uriToMemFsPath(defaultIncPath)}`);
+    compileOptions.push(`-p${(0, CustomWasmFS_1.uriToMemFsPath)(defaultIncPath)}`);
     const dloLibs = await dependencies_1.Dependencies.getApmPartDependencies(cwd, fs, apm_1.APM.Part.dlo);
     for (const dloLib of dloLibs) {
         const dirName = vscode_uri_1.Utils.dirname(dloLib.path);
-        compileOptions.push(`-i${uriToMemFsPath(dirName)}`);
+        compileOptions.push(`-i${(0, CustomWasmFS_1.uriToMemFsPath)(dirName)}`);
     }
     const dloConfiguration = manifest.dlo;
     if (dloConfiguration) {

package/out/dlo/dlo.js

@@ -6,6 +6,7 @@ const preCompiler_1 = require("./preCompiler");
 const manifest_1 = require("../manifest");
 const compiler_1 = require("./compiler");
 const defaultFiles_1 = require("../defaultFiles");
+const CustomWasmFS_1 = require("./CustomWasmFS");
 var DLO;
 (function (DLO) {
     DLO.FileSequencer = fileSequencer_1.DloFileSequencer;
@@ -14,7 +15,7 @@ var DLO;
      * The DLO Compiler
      */
     DLO.Compiler = compiler_1.DloCompiler;
-    DLO.uriToMemFs = compiler_1.uriToMemFsPath;
+    DLO.uriToMemFs = CustomWasmFS_1.uriToMemFsPath;
     DLO.parseCompilerWarningsAndErrors = compiler_1.parseWarningsAndErrors;
     /**
      * Generate the dlo.cfg file and write it to the .studio/auto/dlo directory