novac 2.2.0 → 2.2.2

package/novac/kits/kitlibfs/kitdef.js

@@ -1,231 +0,0 @@
-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/novac/kits/kitlibproc/kitdef.js

@@ -1,78 +0,0 @@
-// kitlibproc — process & shell execution kit for Nova
-// Synchronous wrappers around child_process for scripting use.
-const { execSync, spawnSync } = require('child_process');
-const os   = require('os');
-const path = require('path');
-const fs   = require('fs');
-
-const proc = {
-  // Run a shell command, return stdout string. Throws on non-zero exit.
-  exec(cmd, options = {}) {
-    const { cwd = process.cwd(), env = process.env, timeout = 30000 } = options;
-    return execSync(cmd, { encoding: 'utf8', cwd, env, timeout }).trimEnd();
-  },
-
-  // Run a command, return { code, stdout, stderr } — never throws.
-  run(cmd, options = {}) {
-    const { cwd = process.cwd(), env = process.env, timeout = 30000 } = options;
-    try {
-      const stdout = execSync(cmd, { encoding: 'utf8', cwd, env, timeout, stdio: ['ignore', 'pipe', 'pipe'] }).trimEnd();
-      return { code: 0, stdout, stderr: '' };
-    } catch (e) {
-      return { code: e.status || 1, stdout: (e.stdout || '').trimEnd(), stderr: (e.stderr || '').trimEnd() };
-    }
-  },
-
-  // Spawn a process with explicit argv, return { code, stdout, stderr }
-  spawn(bin, args = [], options = {}) {
-    const { cwd = process.cwd(), env = process.env, timeout = 30000 } = options;
-    const result = spawnSync(bin, args, { encoding: 'utf8', cwd, env, timeout });
-    return {
-      code: result.status ?? 1,
-      stdout: (result.stdout || '').trimEnd(),
-      stderr: (result.stderr || '').trimEnd(),
-    };
-  },
-
-  // Exit current process
-  exit(code = 0) { process.exit(code); },
-
-  // Environment variable access
-  env(key) { return process.env[key] ?? null; },
-  setEnv(key, value) { process.env[key] = String(value); },
-
-  // Current working directory
-  cwd() { return process.cwd(); },
-  chdir(dir) { process.chdir(dir); },
-
-  // Platform info
-  platform() { return os.platform(); },
-  arch() { return os.arch(); },
-  hostname() { return os.hostname(); },
-  cpus() { return os.cpus().length; },
-  mem() { return { total: os.totalmem(), free: os.freemem() }; },
-
-  // Temp file helpers
-  tmpFile(ext = '.tmp') {
-    return path.join(os.tmpdir(), `nv_tmp_${Date.now()}${ext}`);
-  },
-  tmpDir() {
-    const d = fs.mkdtempSync(path.join(os.tmpdir(), 'nova_'));
-    return d;
-  },
-
-  // Sleep (blocking) in ms
-  sleepSync(ms) {
-    const t = Date.now() + ms;
-    while (Date.now() < t) { /* spin */ }
-  },
-
-  // PID of current process
-  pid() { return process.pid; },
-
-  // argv passthrough
-  argv() { return process.argv.slice(2); },
-  ...process
-};
-
-module.exports = { kitdef: proc };

package/novac/kits/kitmatrix/ex.js

@@ -1,19 +0,0 @@
-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()