novac 2.0.1 → 2.2.0

package/novac/kits/kitlibfs/kitdef.js

@@ -0,0 +1,231 @@
+const { kStringMaxLength } = require('buffer');
+const fs = require('fs');
+const path = require('path');
+
+const filesystem = {
+    //note:this implementation is completely synchronous, It is only intended for use in development and testing environments.
+    //it should have all fs methods, but synchronous versions only. 
+    read: (filePath, encoding = 'utf8') => {
+        const absolutePath = path.resolve(filePath);
+        if (!fs.existsSync(absolutePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        return fs.readFileSync(absolutePath, encoding);
+    },
+    write: (filePath, content, encoding = 'utf8') => {
+        const absolutePath = path.resolve(filePath);
+        fs.writeFileSync(absolutePath, content, encoding);
+    },
+    exists: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        return fs.existsSync(absolutePath);
+    },
+    delete: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        if (fs.existsSync(absolutePath)) {
+            fs.unlinkSync(absolutePath);
+        }
+    },
+    list: (directoryPath) => {
+        const absolutePath = path.resolve(directoryPath);
+        return fs.readdirSync(absolutePath);
+    },
+    isDirectory: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        return fs.statSync(absolutePath).isDirectory();
+    },
+    createDirectory: (directoryPath) => {
+        const absolutePath = path.resolve(directoryPath);
+        fs.mkdirSync(absolutePath);
+    },
+    deleteDirectory: (directoryPath) => {
+        const absolutePath = path.resolve(directoryPath);
+        if (fs.existsSync(absolutePath)) {
+            fs.rmdirSync(absolutePath);
+        }
+    },
+    stats: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        return fs.statSync(absolutePath);
+    },
+    cp: (sourcePath, destinationPath) => {
+        const absoluteSourcePath = path.resolve(sourcePath);
+        const absoluteDestinationPath = path.resolve(destinationPath);
+        fs.copyFileSync(absoluteSourcePath, absoluteDestinationPath);
+    },
+    cpDir: (sourceDir, destinationDir) => {
+        const absoluteSourceDir = path.resolve(sourceDir);
+        const absoluteDestinationDir = path.resolve(destinationDir);
+        if (!fs.existsSync(absoluteDestinationDir)) {
+            fs.mkdirSync(absoluteDestinationDir);
+        }
+        const items = fs.readdirSync(absoluteSourceDir);
+        items.forEach(item => {
+            const sourceItemPath = path.join(absoluteSourceDir, item);
+            const destinationItemPath = path.join(absoluteDestinationDir, item);
+            if (fs.statSync(sourceItemPath).isDirectory()) {
+                filesystem.cpDir(sourceItemPath, destinationItemPath);
+            } else {
+                fs.copyFileSync(sourceItemPath, destinationItemPath);
+            }
+        });
+    },
+    appendFile: (filePath, content, encoding = 'utf8') => {
+        const absolutePath = path.resolve(filePath);
+        fs.appendFileSync(absolutePath, content, encoding);
+    },
+    rename: (oldPath, newPath) => {
+        const absoluteOldPath = path.resolve(oldPath);
+        const absoluteNewPath = path.resolve(newPath);
+        fs.renameSync(absoluteOldPath, absoluteNewPath);
+    },
+    access: (filePath, mode = fs.constants.F_OK) => {
+        const absolutePath = path.resolve(filePath);
+        try {
+            fs.accessSync(absolutePath, mode);
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    chmod: (filePath, mode) => {
+        const absolutePath = path.resolve(filePath);
+        fs.chmodSync(absolutePath, mode);
+    },
+    readlink: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        return fs.readlinkSync(absolutePath);
+    },
+    symlink: (target, filePath, type = 'file') => {
+        const absoluteTarget = path.resolve(target);
+        const absolutePath = path.resolve(filePath);
+        fs.symlinkSync(absoluteTarget, absolutePath, type);
+    },
+    link: (existingPath, newPath) => {
+        const absoluteExistingPath = path.resolve(existingPath);
+        const absoluteNewPath = path.resolve(newPath);
+        fs.linkSync(absoluteExistingPath, absoluteNewPath);
+    },
+    lstat: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        return fs.lstatSync(absolutePath);
+    },
+    realpath: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        return fs.realpathSync(absolutePath);
+    },
+    isFile: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        if (!fs.existsSync(absolutePath)) return false;
+        return fs.statSync(absolutePath).isFile();
+    },
+    isSymbolicLink: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        if (!fs.existsSync(absolutePath)) return false;
+        return fs.lstatSync(absolutePath).isSymbolicLink();
+    },
+    truncate: (filePath, len = 0) => {
+        const absolutePath = path.resolve(filePath);
+        fs.truncateSync(absolutePath, len);
+    },
+    mkdtemp: (prefix) => {
+        return fs.mkdtempSync(prefix);
+    },
+    rm: (filePath, options = {}) => {
+        const absolutePath = path.resolve(filePath);
+        if (fs.existsSync(absolutePath)) {
+            const stat = fs.statSync(absolutePath);
+            if (stat.isDirectory()) {
+                if (options.recursive) {
+                    fs.rmSync(absolutePath, { recursive: true });
+                } else {
+                    fs.rmdirSync(absolutePath);
+                }
+            } else {
+                fs.unlinkSync(absolutePath);
+            }
+        }
+    },
+    dirents: (directoryPath) => {
+        const absolutePath = path.resolve(directoryPath);
+        return fs.readdirSync(absolutePath, { withFileTypes: true });
+    },
+    // Path utilities
+    pathDirname: (filePath) => {
+        return path.dirname(filePath);
+    },
+    pathBasename: (filePath, ext = '') => {
+        return path.basename(filePath, ext);
+    },
+    pathExtname: (filePath) => {
+        return path.extname(filePath);
+    },
+    pathJoin: (...paths) => {
+        return path.join(...paths);
+    },
+    pathResolve: (...paths) => {
+        return path.resolve(...paths);
+    },
+    pathRelative: (from, to) => {
+        return path.relative(from, to);
+    },
+    pathNormalize: (filePath) => {
+        return path.normalize(filePath);
+    },
+    pathParse: (filePath) => {
+        return path.parse(filePath);
+    },
+    pathFormat: (pathObj) => {
+        return path.format(pathObj);
+    },
+    pathIsAbsolute: (filePath) => {
+        return path.isAbsolute(filePath);
+    },
+    getSize: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        return fs.statSync(absolutePath).size;
+    },
+    isReadable: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        try {
+            fs.accessSync(absolutePath, fs.constants.R_OK);
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    isWritable: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        try {
+            fs.accessSync(absolutePath, fs.constants.W_OK);
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    isExecutable: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        try {
+            fs.accessSync(absolutePath, fs.constants.X_OK);
+            return true;
+        } catch {
+            return false;
+        }
+    },
+    getModifiedTime: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        return fs.statSync(absolutePath).mtime;
+    },
+    getCreatedTime: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        return fs.statSync(absolutePath).birthtime;
+    },
+    getAccessedTime: (filePath) => {
+        const absolutePath = path.resolve(filePath);
+        return fs.statSync(absolutePath).atime;
+    },
+};
+
+module.exports = {
+    kitdef: filesystem  
+};

package/{examples/example-project/nova_modules → novac/kits}/kitlibproc/kitdef.js

@@ -54,7 +54,7 @@ const proc = {
 
   // Temp file helpers
   tmpFile(ext = '.tmp') {
-    return path.join(os.tmpdir(), `nova_${Date.now()}${ext}`);
+    return path.join(os.tmpdir(), `nv_tmp_${Date.now()}${ext}`);
   },
   tmpDir() {
     const d = fs.mkdtempSync(path.join(os.tmpdir(), 'nova_'));
@@ -62,7 +62,7 @@ const proc = {
   },
 
   // Sleep (blocking) in ms
-  sleep(ms) {
+  sleepSync(ms) {
     const t = Date.now() + ms;
     while (Date.now() < t) { /* spin */ }
   },
@@ -72,6 +72,7 @@ const proc = {
 
   // argv passthrough
   argv() { return process.argv.slice(2); },
+  ...process
 };
 
 module.exports = { kitdef: proc };

package/novac/kits/kitmatrix/ex.js

@@ -0,0 +1,19 @@
+const { Matrix } = require("./kitdef").kitdef;
+
+const m = new Matrix(20, 20);
+
+const grid = m.grid(10, 10, 0, 0, 2, 2);
+
+const player = grid.at(2, 2)
+  .clone()
+  .withLabel("@");
+
+const target = grid.at(8, 7)
+  .clone()
+  .withLabel("X");
+
+console.log(player.distanceTo(target));
+
+const neighbors = grid.neighbors(2, 2, true);
+
+m.render.frame()