@highstate/designer 0.2.2 → 0.3.3

package/.output/server/node_modules/watcher/dist/watcher_locker.js

@@ -0,0 +1,139 @@
+/* IMPORT */
+import { RENAME_TIMEOUT } from './constants.js';
+import { FileType, TargetEvent } from './enums.js';
+import Utils from './utils.js';
+import WatcherLocksResolver from './watcher_locks_resolver.js';
+/* MAIN */
+//TODO: Use a better name for this thing, maybe "RenameDetector"
+class WatcherLocker {
+    /* CONSTRUCTOR */
+    constructor(watcher) {
+        this._watcher = watcher;
+        this.reset();
+    }
+    /* API */
+    getLockAdd(config, timeout = RENAME_TIMEOUT) {
+        const { ino, targetPath, events, locks } = config;
+        const emit = () => {
+            const otherPath = this._watcher._poller.paths.find(ino || -1, path => path !== targetPath); // Maybe this is actually a rename in a case-insensitive filesystem
+            if (otherPath && otherPath !== targetPath) {
+                if (Utils.fs.getRealPath(targetPath, true) === otherPath)
+                    return; //TODO: This seems a little too special-casey
+                this._watcher.event(events.rename, otherPath, targetPath);
+            }
+            else {
+                this._watcher.event(events.add, targetPath);
+            }
+        };
+        if (!ino)
+            return emit();
+        const cleanup = () => {
+            locks.add.delete(ino);
+            WatcherLocksResolver.remove(free);
+        };
+        const free = () => {
+            cleanup();
+            emit();
+        };
+        WatcherLocksResolver.add(free, timeout);
+        const resolve = () => {
+            const unlink = locks.unlink.get(ino);
+            if (!unlink)
+                return; // No matching "unlink" lock found, skipping
+            cleanup();
+            const targetPathPrev = unlink();
+            if (targetPath === targetPathPrev) {
+                if (events.change) {
+                    if (this._watcher._poller.stats.has(targetPath)) {
+                        this._watcher.event(events.change, targetPath);
+                    }
+                }
+            }
+            else {
+                this._watcher.event(events.rename, targetPathPrev, targetPath);
+            }
+        };
+        locks.add.set(ino, resolve);
+        resolve();
+    }
+    getLockUnlink(config, timeout = RENAME_TIMEOUT) {
+        const { ino, targetPath, events, locks } = config;
+        const emit = () => {
+            this._watcher.event(events.unlink, targetPath);
+        };
+        if (!ino)
+            return emit();
+        const cleanup = () => {
+            locks.unlink.delete(ino);
+            WatcherLocksResolver.remove(free);
+        };
+        const free = () => {
+            cleanup();
+            emit();
+        };
+        WatcherLocksResolver.add(free, timeout);
+        const overridden = () => {
+            cleanup();
+            return targetPath;
+        };
+        locks.unlink.set(ino, overridden);
+        locks.add.get(ino)?.();
+    }
+    getLockTargetAdd(targetPath, timeout) {
+        const ino = this._watcher._poller.getIno(targetPath, TargetEvent.ADD, FileType.FILE);
+        return this.getLockAdd({
+            ino,
+            targetPath,
+            events: WatcherLocker.FILE_EVENTS,
+            locks: this._locksFile
+        }, timeout);
+    }
+    getLockTargetAddDir(targetPath, timeout) {
+        const ino = this._watcher._poller.getIno(targetPath, TargetEvent.ADD_DIR, FileType.DIR);
+        return this.getLockAdd({
+            ino,
+            targetPath,
+            events: WatcherLocker.DIR_EVENTS,
+            locks: this._locksDir
+        }, timeout);
+    }
+    getLockTargetUnlink(targetPath, timeout) {
+        const ino = this._watcher._poller.getIno(targetPath, TargetEvent.UNLINK, FileType.FILE);
+        return this.getLockUnlink({
+            ino,
+            targetPath,
+            events: WatcherLocker.FILE_EVENTS,
+            locks: this._locksFile
+        }, timeout);
+    }
+    getLockTargetUnlinkDir(targetPath, timeout) {
+        const ino = this._watcher._poller.getIno(targetPath, TargetEvent.UNLINK_DIR, FileType.DIR);
+        return this.getLockUnlink({
+            ino,
+            targetPath,
+            events: WatcherLocker.DIR_EVENTS,
+            locks: this._locksDir
+        }, timeout);
+    }
+    reset() {
+        this._locksAdd = new Map();
+        this._locksAddDir = new Map();
+        this._locksUnlink = new Map();
+        this._locksUnlinkDir = new Map();
+        this._locksDir = { add: this._locksAddDir, unlink: this._locksUnlinkDir };
+        this._locksFile = { add: this._locksAdd, unlink: this._locksUnlink };
+    }
+}
+WatcherLocker.DIR_EVENTS = {
+    add: TargetEvent.ADD_DIR,
+    rename: TargetEvent.RENAME_DIR,
+    unlink: TargetEvent.UNLINK_DIR
+};
+WatcherLocker.FILE_EVENTS = {
+    add: TargetEvent.ADD,
+    change: TargetEvent.CHANGE,
+    rename: TargetEvent.RENAME,
+    unlink: TargetEvent.UNLINK
+};
+/* EXPORT */
+export default WatcherLocker;

package/.output/server/node_modules/watcher/dist/watcher_locks_resolver.js

@@ -0,0 +1,42 @@
+/* MAIN */
+// Registering a single interval scales much better than registering N timeouts
+// Timeouts are respected within the interval margin
+const WatcherLocksResolver = {
+    /* VARIABLES */
+    interval: 100,
+    intervalId: undefined,
+    fns: new Map(),
+    /* LIFECYCLE API */
+    init: () => {
+        if (WatcherLocksResolver.intervalId)
+            return;
+        WatcherLocksResolver.intervalId = setInterval(WatcherLocksResolver.resolve, WatcherLocksResolver.interval);
+    },
+    reset: () => {
+        if (!WatcherLocksResolver.intervalId)
+            return;
+        clearInterval(WatcherLocksResolver.intervalId);
+        delete WatcherLocksResolver.intervalId;
+    },
+    /* API */
+    add: (fn, timeout) => {
+        WatcherLocksResolver.fns.set(fn, Date.now() + timeout);
+        WatcherLocksResolver.init();
+    },
+    remove: (fn) => {
+        WatcherLocksResolver.fns.delete(fn);
+    },
+    resolve: () => {
+        if (!WatcherLocksResolver.fns.size)
+            return WatcherLocksResolver.reset();
+        const now = Date.now();
+        for (const [fn, timestamp] of WatcherLocksResolver.fns) {
+            if (timestamp >= now)
+                continue; // We should still wait some more for this
+            WatcherLocksResolver.remove(fn);
+            fn();
+        }
+    }
+};
+/* EXPORT */
+export default WatcherLocksResolver;

package/.output/server/node_modules/watcher/dist/watcher_poller.js

@@ -0,0 +1,116 @@
+/* IMPORT */
+import { FileType, TargetEvent } from './enums.js';
+import LazyMapSet from './lazy_map_set.js';
+import Utils from './utils.js';
+import WatcherStats from './watcher_stats.js';
+/* MAIN */
+class WatcherPoller {
+    constructor() {
+        /* VARIABLES */
+        this.inos = {};
+        this.paths = new LazyMapSet();
+        this.stats = new Map();
+    }
+    /* API */
+    getIno(targetPath, event, type) {
+        const inos = this.inos[event];
+        if (!inos)
+            return;
+        const ino = inos[targetPath];
+        if (!ino)
+            return;
+        if (type && ino[1] !== type)
+            return;
+        return ino[0];
+    }
+    getStats(targetPath) {
+        return this.stats.get(targetPath);
+    }
+    async poll(targetPath, timeout) {
+        const stats = await Utils.fs.poll(targetPath, timeout);
+        if (!stats)
+            return;
+        const isSupported = stats.isFile() || stats.isDirectory();
+        if (!isSupported)
+            return;
+        return new WatcherStats(stats);
+    }
+    reset() {
+        this.inos = {};
+        this.paths = new LazyMapSet();
+        this.stats = new Map();
+    }
+    async update(targetPath, timeout) {
+        const prev = this.getStats(targetPath);
+        const next = await this.poll(targetPath, timeout);
+        this.updateStats(targetPath, next);
+        if (!prev && next) {
+            if (next.isFile()) {
+                this.updateIno(targetPath, TargetEvent.ADD, next);
+                return [TargetEvent.ADD];
+            }
+            if (next.isDirectory()) {
+                this.updateIno(targetPath, TargetEvent.ADD_DIR, next);
+                return [TargetEvent.ADD_DIR];
+            }
+        }
+        else if (prev && !next) {
+            if (prev.isFile()) {
+                this.updateIno(targetPath, TargetEvent.UNLINK, prev);
+                return [TargetEvent.UNLINK];
+            }
+            if (prev.isDirectory()) {
+                this.updateIno(targetPath, TargetEvent.UNLINK_DIR, prev);
+                return [TargetEvent.UNLINK_DIR];
+            }
+        }
+        else if (prev && next) {
+            if (prev.isFile()) {
+                if (next.isFile()) {
+                    if (prev.ino === next.ino && !prev.size && !next.size)
+                        return []; // Same path, same content and same file, nothing actually changed
+                    this.updateIno(targetPath, TargetEvent.CHANGE, next);
+                    return [TargetEvent.CHANGE];
+                }
+                if (next.isDirectory()) {
+                    this.updateIno(targetPath, TargetEvent.UNLINK, prev);
+                    this.updateIno(targetPath, TargetEvent.ADD_DIR, next);
+                    return [TargetEvent.UNLINK, TargetEvent.ADD_DIR];
+                }
+            }
+            else if (prev.isDirectory()) {
+                if (next.isFile()) {
+                    this.updateIno(targetPath, TargetEvent.UNLINK_DIR, prev);
+                    this.updateIno(targetPath, TargetEvent.ADD, next);
+                    return [TargetEvent.UNLINK_DIR, TargetEvent.ADD];
+                }
+                if (next.isDirectory()) {
+                    if (prev.ino === next.ino)
+                        return []; // Same path and same directory, nothing actually changed
+                    this.updateIno(targetPath, TargetEvent.UNLINK_DIR, prev);
+                    this.updateIno(targetPath, TargetEvent.ADD_DIR, next);
+                    return [TargetEvent.UNLINK_DIR, TargetEvent.ADD_DIR];
+                }
+            }
+        }
+        return [];
+    }
+    updateIno(targetPath, event, stats) {
+        const inos = this.inos[event] = this.inos[event] || (this.inos[event] = {});
+        const type = stats.isFile() ? FileType.FILE : FileType.DIR;
+        inos[targetPath] = [stats.ino, type];
+    }
+    updateStats(targetPath, stats) {
+        if (stats) {
+            this.paths.set(stats.ino, targetPath);
+            this.stats.set(targetPath, stats);
+        }
+        else {
+            const ino = this.stats.get(targetPath)?.ino || -1;
+            this.paths.delete(ino, targetPath);
+            this.stats.delete(targetPath);
+        }
+    }
+}
+/* EXPORT */
+export default WatcherPoller;

package/.output/server/node_modules/watcher/dist/watcher_stats.js

@@ -0,0 +1,29 @@
+/* IMPORT */
+/* MAIN */
+// An more memory-efficient representation of the useful subset of stats objects
+class WatcherStats {
+    /* CONSTRUCTOR */
+    constructor(stats) {
+        this.ino = (stats.ino <= Number.MAX_SAFE_INTEGER) ? Number(stats.ino) : stats.ino;
+        this.size = Number(stats.size);
+        this.atimeMs = Number(stats.atimeMs);
+        this.mtimeMs = Number(stats.mtimeMs);
+        this.ctimeMs = Number(stats.ctimeMs);
+        this.birthtimeMs = Number(stats.birthtimeMs);
+        this._isFile = stats.isFile();
+        this._isDirectory = stats.isDirectory();
+        this._isSymbolicLink = stats.isSymbolicLink();
+    }
+    /* API */
+    isFile() {
+        return this._isFile;
+    }
+    isDirectory() {
+        return this._isDirectory;
+    }
+    isSymbolicLink() {
+        return this._isSymbolicLink;
+    }
+}
+/* EXPORT */
+export default WatcherStats;

package/.output/server/node_modules/watcher/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "watcher",
+  "repository": "github:fabiospampinato/watcher",
+  "description": "The file system watcher that strives for perfection, with no native dependencies and optional rename detection support.",
+  "version": "2.3.1",
+  "type": "module",
+  "main": "dist/watcher.js",
+  "exports": "./dist/watcher.js",
+  "types": "./dist/watcher.d.ts",
+  "scripts": {
+    "clean": "tsex clean",
+    "compile": "tsex compile",
+    "compile:watch": "tsex compile --watch",
+    "test": "tsex test",
+    "test:watch": "tsex test --watch",
+    "prepublishOnly": "tsex prepare"
+  },
+  "keywords": [
+    "fs",
+    "file",
+    "system",
+    "filesystem",
+    "watch",
+    "watcher"
+  ],
+  "dependencies": {
+    "dettle": "^1.0.2",
+    "stubborn-fs": "^1.2.5",
+    "tiny-readdir": "^2.7.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.4.6",
+    "fava": "^0.2.0",
+    "tsex": "^3.0.0",
+    "typescript": "^5.1.6"
+  }
+}

package/.output/server/node_modules/which/package.json

@@ -0,0 +1,43 @@
+{
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me)",
+  "name": "which",
+  "description": "Like which(1) unix command. Find the first instance of an executable in the PATH.",
+  "version": "2.0.2",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/node-which.git"
+  },
+  "main": "which.js",
+  "bin": {
+    "node-which": "./bin/node-which"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "isexe": "^2.0.0"
+  },
+  "devDependencies": {
+    "mkdirp": "^0.5.0",
+    "rimraf": "^2.6.2",
+    "tap": "^14.6.9"
+  },
+  "scripts": {
+    "test": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "prepublish": "npm run changelog",
+    "prechangelog": "bash gen-changelog.sh",
+    "changelog": "git add CHANGELOG.md",
+    "postchangelog": "git commit -m 'update changelog - '${npm_package_version}",
+    "postpublish": "git push origin --follow-tags"
+  },
+  "files": [
+    "which.js",
+    "bin/node-which"
+  ],
+  "tap": {
+    "check-coverage": true
+  },
+  "engines": {
+    "node": ">= 8"
+  }
+}

package/.output/server/node_modules/which/which.js

@@ -0,0 +1,125 @@
+const isWindows = process.platform === 'win32' ||
+    process.env.OSTYPE === 'cygwin' ||
+    process.env.OSTYPE === 'msys'
+
+const path = require('path')
+const COLON = isWindows ? ';' : ':'
+const isexe = require('isexe')
+
+const getNotFoundError = (cmd) =>
+  Object.assign(new Error(`not found: ${cmd}`), { code: 'ENOENT' })
+
+const getPathInfo = (cmd, opt) => {
+  const colon = opt.colon || COLON
+
+  // If it has a slash, then we don't bother searching the pathenv.
+  // just check the file itself, and that's it.
+  const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? ['']
+    : (
+      [
+        // windows always checks the cwd first
+        ...(isWindows ? [process.cwd()] : []),
+        ...(opt.path || process.env.PATH ||
+          /* istanbul ignore next: very unusual */ '').split(colon),
+      ]
+    )
+  const pathExtExe = isWindows
+    ? opt.pathExt || process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM'
+    : ''
+  const pathExt = isWindows ? pathExtExe.split(colon) : ['']
+
+  if (isWindows) {
+    if (cmd.indexOf('.') !== -1 && pathExt[0] !== '')
+      pathExt.unshift('')
+  }
+
+  return {
+    pathEnv,
+    pathExt,
+    pathExtExe,
+  }
+}
+
+const which = (cmd, opt, cb) => {
+  if (typeof opt === 'function') {
+    cb = opt
+    opt = {}
+  }
+  if (!opt)
+    opt = {}
+
+  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt)
+  const found = []
+
+  const step = i => new Promise((resolve, reject) => {
+    if (i === pathEnv.length)
+      return opt.all && found.length ? resolve(found)
+        : reject(getNotFoundError(cmd))
+
+    const ppRaw = pathEnv[i]
+    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw
+
+    const pCmd = path.join(pathPart, cmd)
+    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
+      : pCmd
+
+    resolve(subStep(p, i, 0))
+  })
+
+  const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+    if (ii === pathExt.length)
+      return resolve(step(i + 1))
+    const ext = pathExt[ii]
+    isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+      if (!er && is) {
+        if (opt.all)
+          found.push(p + ext)
+        else
+          return resolve(p + ext)
+      }
+      return resolve(subStep(p, i, ii + 1))
+    })
+  })
+
+  return cb ? step(0).then(res => cb(null, res), cb) : step(0)
+}
+
+const whichSync = (cmd, opt) => {
+  opt = opt || {}
+
+  const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt)
+  const found = []
+
+  for (let i = 0; i < pathEnv.length; i ++) {
+    const ppRaw = pathEnv[i]
+    const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw
+
+    const pCmd = path.join(pathPart, cmd)
+    const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd
+      : pCmd
+
+    for (let j = 0; j < pathExt.length; j ++) {
+      const cur = p + pathExt[j]
+      try {
+        const is = isexe.sync(cur, { pathExt: pathExtExe })
+        if (is) {
+          if (opt.all)
+            found.push(cur)
+          else
+            return cur
+        }
+      } catch (ex) {}
+    }
+  }
+
+  if (opt.all && found.length)
+    return found
+
+  if (opt.nothrow)
+    return null
+
+  throw getNotFoundError(cmd)
+}
+
+module.exports = which
+which.sync = whichSync

package/.output/server/node_modules/wrappy/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "wrappy",
+  "version": "1.0.2",
+  "description": "Callback wrapping utility",
+  "main": "wrappy.js",
+  "files": [
+    "wrappy.js"
+  ],
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "tap": "^2.3.1"
+  },
+  "scripts": {
+    "test": "tap --coverage test/*.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/npm/wrappy"
+  },
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/npm/wrappy/issues"
+  },
+  "homepage": "https://github.com/npm/wrappy"
+}

package/.output/server/node_modules/wrappy/wrappy.js

@@ -0,0 +1,33 @@
+// Returns a wrapper function that returns a wrapped callback
+// The wrapper function should do some stuff, and return a
+// presumably different callback function.
+// This makes sure that own properties are retained, so that
+// decorations and such are not lost along the way.
+module.exports = wrappy
+function wrappy (fn, cb) {
+  if (fn && cb) return wrappy(fn)(cb)
+
+  if (typeof fn !== 'function')
+    throw new TypeError('need wrapper function')
+
+  Object.keys(fn).forEach(function (k) {
+    wrapper[k] = fn[k]
+  })
+
+  return wrapper
+
+  function wrapper() {
+    var args = new Array(arguments.length)
+    for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i]
+    }
+    var ret = fn.apply(this, args)
+    var cb = args[args.length-1]
+    if (typeof ret === 'function' && ret !== cb) {
+      Object.keys(cb).forEach(function (k) {
+        ret[k] = cb[k]
+      })
+    }
+    return ret
+  }
+}