@highstate/designer 0.3.2 → 0.3.3

package/.output/server/node_modules/nypm/dist/index.mjs

@@ -0,0 +1,306 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { normalize, resolve, join } from 'pathe';
+import { createRequire } from 'node:module';
+import { withTrailingSlash } from 'ufo';
+import { readPackageJSON } from 'pkg-types';
+
+async function findup(cwd, match, options = {}) {
+  const segments = normalize(cwd).split("/");
+  while (segments.length > 0) {
+    const path = segments.join("/") || "/";
+    const result = await match(path);
+    if (result || !options.includeParentDirs) {
+      return result;
+    }
+    segments.pop();
+  }
+}
+function cached(fn) {
+  let v;
+  return () => {
+    if (v === void 0) {
+      v = fn().then((r) => {
+        v = r;
+        return v;
+      });
+    }
+    return v;
+  };
+}
+const importTinyexec = cached(() => import('tinyexec').then((r) => r.x));
+const hasCorepack = cached(async () => {
+  const x = await importTinyexec();
+  const result = x("corepack", ["--version"]);
+  await result;
+  return result.exitCode === 0;
+});
+async function executeCommand(command, args, options = {}) {
+  const xArgs = command === "npm" || command === "bun" || command === "deno" || !await hasCorepack() ? [command, args] : ["corepack", [command, ...args]];
+  const x = await importTinyexec();
+  await x(xArgs[0], xArgs[1], {
+    nodeOptions: {
+      cwd: resolve(options.cwd || process.cwd()),
+      stdio: options.silent ? "pipe" : "inherit"
+    }
+  });
+}
+const NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG = "No package manager auto-detected.";
+async function resolveOperationOptions(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const packageManager = (typeof options.packageManager === "string" ? packageManagers.find((pm) => pm.name === options.packageManager) : options.packageManager) || await detectPackageManager(options.cwd || process.cwd());
+  if (!packageManager) {
+    throw new Error(NO_PACKAGE_MANAGER_DETECTED_ERROR_MSG);
+  }
+  return {
+    cwd,
+    silent: options.silent ?? false,
+    packageManager,
+    dev: options.dev ?? false,
+    workspace: options.workspace,
+    global: options.global ?? false
+  };
+}
+function getWorkspaceArgs(options) {
+  if (!options.workspace) {
+    return [];
+  }
+  const workspacePkg = typeof options.workspace === "string" && options.workspace !== "" ? options.workspace : void 0;
+  if (options.packageManager.name === "pnpm") {
+    return workspacePkg ? ["--filter", workspacePkg] : ["--workspace-root"];
+  }
+  if (options.packageManager.name === "npm") {
+    return workspacePkg ? ["-w", workspacePkg] : ["--workspaces"];
+  }
+  if (options.packageManager.name === "yarn") {
+    if (!options.packageManager.majorVersion || options.packageManager.majorVersion === "1") {
+      return workspacePkg ? ["--cwd", workspacePkg] : ["-W"];
+    } else {
+      return workspacePkg ? ["workspace", workspacePkg] : [];
+    }
+  }
+  return [];
+}
+function doesDependencyExist(name, options) {
+  const require = createRequire(withTrailingSlash(options.cwd));
+  try {
+    const resolvedPath = require.resolve(name);
+    return resolvedPath.startsWith(options.cwd);
+  } catch {
+    return false;
+  }
+}
+
+const packageManagers = [
+  {
+    name: "npm",
+    command: "npm",
+    lockFile: "package-lock.json"
+  },
+  {
+    name: "pnpm",
+    command: "pnpm",
+    lockFile: "pnpm-lock.yaml",
+    files: ["pnpm-workspace.yaml"]
+  },
+  {
+    name: "bun",
+    command: "bun",
+    lockFile: ["bun.lockb", "bun.lock"]
+  },
+  {
+    name: "yarn",
+    command: "yarn",
+    majorVersion: "1",
+    lockFile: "yarn.lock"
+  },
+  {
+    name: "yarn",
+    command: "yarn",
+    majorVersion: "3",
+    lockFile: "yarn.lock",
+    files: [".yarnrc.yml"]
+  },
+  {
+    name: "deno",
+    command: "deno",
+    lockFile: "deno.lock",
+    files: ["deno.json"]
+  }
+];
+async function detectPackageManager(cwd, options = {}) {
+  const detected = await findup(
+    resolve(cwd || "."),
+    async (path) => {
+      if (!options.ignorePackageJSON) {
+        const packageJSONPath = join(path, "package.json");
+        if (existsSync(packageJSONPath)) {
+          const packageJSON = JSON.parse(
+            await readFile(packageJSONPath, "utf8")
+          );
+          if (packageJSON?.packageManager) {
+            const [name, version = "0.0.0"] = packageJSON.packageManager.split("@");
+            const majorVersion = version.split(".")[0];
+            const packageManager = packageManagers.find(
+              (pm) => pm.name === name && pm.majorVersion === majorVersion
+            ) || packageManagers.find((pm) => pm.name === name);
+            return {
+              ...packageManager,
+              name,
+              command: name,
+              version,
+              majorVersion
+            };
+          }
+        }
+        const denoJSONPath = join(path, "deno.json");
+        if (existsSync(denoJSONPath)) {
+          return packageManagers.find((pm) => pm.name === "deno");
+        }
+      }
+      if (!options.ignoreLockFile) {
+        for (const packageManager of packageManagers) {
+          const detectionsFiles = [
+            packageManager.lockFile,
+            packageManager.files
+          ].flat().filter(Boolean);
+          if (detectionsFiles.some((file) => existsSync(resolve(path, file)))) {
+            return {
+              ...packageManager
+            };
+          }
+        }
+      }
+    },
+    {
+      includeParentDirs: options.includeParentDirs ?? true
+    }
+  );
+  if (!detected && !options.ignoreArgv) {
+    const scriptArg = process.argv[1];
+    if (scriptArg) {
+      for (const packageManager of packageManagers) {
+        const re = new RegExp(`[/\\\\]\\.?${packageManager.command}`);
+        if (re.test(scriptArg)) {
+          return packageManager;
+        }
+      }
+    }
+  }
+  return detected;
+}
+
+async function installDependencies(options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  const pmToFrozenLockfileInstallCommand = {
+    npm: ["ci"],
+    yarn: ["install", "--immutable"],
+    bun: ["install", "--frozen-lockfile"],
+    pnpm: ["install", "--frozen-lockfile"],
+    deno: ["install", "--frozen"]
+  };
+  const commandArgs = options.frozenLockFile ? pmToFrozenLockfileInstallCommand[resolvedOptions.packageManager.name] : ["install"];
+  await executeCommand(resolvedOptions.packageManager.command, commandArgs, {
+    cwd: resolvedOptions.cwd,
+    silent: resolvedOptions.silent
+  });
+}
+async function addDependency(name, options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  const names = Array.isArray(name) ? name : [name];
+  if (resolvedOptions.packageManager.name === "deno") {
+    for (let i = 0; i < names.length; i++) {
+      if (!/^(npm|jsr|file):.+$/.test(names[i])) {
+        names[i] = `npm:${names[i]}`;
+      }
+    }
+  }
+  if (names.length === 0) {
+    return;
+  }
+  const args = (resolvedOptions.packageManager.name === "yarn" ? [
+    ...getWorkspaceArgs(resolvedOptions),
+    // Global is not supported in berry: yarnpkg/berry#821
+    resolvedOptions.global && resolvedOptions.packageManager.majorVersion === "1" ? "global" : "",
+    "add",
+    resolvedOptions.dev ? "-D" : "",
+    ...names
+  ] : [
+    resolvedOptions.packageManager.name === "npm" ? "install" : "add",
+    ...getWorkspaceArgs(resolvedOptions),
+    resolvedOptions.dev ? "-D" : "",
+    resolvedOptions.global ? "-g" : "",
+    ...names
+  ]).filter(Boolean);
+  await executeCommand(resolvedOptions.packageManager.command, args, {
+    cwd: resolvedOptions.cwd,
+    silent: resolvedOptions.silent
+  });
+  if (options.installPeerDependencies) {
+    const existingPkg = await readPackageJSON(resolvedOptions.cwd);
+    const peerDeps = [];
+    const peerDevDeps = [];
+    for (const _name of names) {
+      const pkgName = _name.match(/^(.[^@]+)/)?.[0];
+      const pkg = await readPackageJSON(pkgName, {
+        url: resolvedOptions.cwd
+      }).catch(() => ({}));
+      if (!pkg.peerDependencies || pkg.name !== pkgName) {
+        continue;
+      }
+      for (const [peerDependency, version] of Object.entries(
+        pkg.peerDependencies
+      )) {
+        if (pkg.peerDependenciesMeta?.[peerDependency]?.optional) {
+          continue;
+        }
+        if (existingPkg.dependencies?.[peerDependency] || existingPkg.devDependencies?.[peerDependency]) {
+          continue;
+        }
+        const isDev = pkg.peerDependenciesMeta?.[peerDependency]?.dev;
+        (isDev ? peerDevDeps : peerDeps).push(`${peerDependency}@${version}`);
+      }
+    }
+    if (peerDeps.length > 0) {
+      await addDependency(peerDeps, { ...resolvedOptions });
+    }
+    if (peerDevDeps.length > 0) {
+      await addDevDependency(peerDevDeps, { ...resolvedOptions });
+    }
+  }
+}
+async function addDevDependency(name, options = {}) {
+  await addDependency(name, { ...options, dev: true });
+}
+async function removeDependency(name, options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  const args = (resolvedOptions.packageManager.name === "yarn" ? [
+    // Global is not supported in berry: yarnpkg/berry#821
+    resolvedOptions.global && resolvedOptions.packageManager.majorVersion === "1" ? "global" : "",
+    ...getWorkspaceArgs(resolvedOptions),
+    "remove",
+    resolvedOptions.dev ? "-D" : "",
+    resolvedOptions.global ? "-g" : "",
+    name
+  ] : [
+    resolvedOptions.packageManager.name === "npm" ? "uninstall" : "remove",
+    ...getWorkspaceArgs(resolvedOptions),
+    resolvedOptions.dev ? "-D" : "",
+    resolvedOptions.global ? "-g" : "",
+    name
+  ]).filter(Boolean);
+  await executeCommand(resolvedOptions.packageManager.command, args, {
+    cwd: resolvedOptions.cwd,
+    silent: resolvedOptions.silent
+  });
+}
+async function ensureDependencyInstalled(name, options = {}) {
+  const resolvedOptions = await resolveOperationOptions(options);
+  const dependencyExists = doesDependencyExist(name, resolvedOptions);
+  if (dependencyExists) {
+    return true;
+  }
+  await addDependency(name, resolvedOptions);
+}
+
+export { addDependency, addDevDependency, detectPackageManager, ensureDependencyInstalled, installDependencies, packageManagers, removeDependency };

package/.output/server/node_modules/nypm/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "nypm",
+  "version": "0.4.1",
+  "description": "Unified Package Manager for Node.js",
+  "repository": "unjs/nypm",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "bin": {
+    "nypm": "./dist/cli.mjs"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "citty": "^0.1.6",
+    "consola": "^3.2.3",
+    "pathe": "^1.1.2",
+    "tinyexec": "^0.3.1",
+    "pkg-types": "^1.2.1",
+    "ufo": "^1.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "@vitest/coverage-v8": "^2.1.6",
+    "automd": "^0.3.12",
+    "changelogen": "^0.5.7",
+    "eslint": "^9.15.0",
+    "eslint-config-unjs": "^0.4.2",
+    "jiti": "^2.4.0",
+    "prettier": "^3.4.1",
+    "std-env": "^3.8.0",
+    "typescript": "^5.7.2",
+    "unbuild": "^2.0.0",
+    "vitest": "^2.1.6"
+  },
+  "engines": {
+    "node": "^14.16.0 || >=16.10.0"
+  },
+  "scripts": {
+    "build": "automd && unbuild",
+    "dev": "vitest dev",
+    "lint": "eslint . && prettier -c src test",
+    "lint:fix": "eslint . --fix && prettier -w src test",
+    "nypm": "jiti src/cli.ts",
+    "release": "pnpm test && pnpm build && changelogen --release --push && pnpm publish",
+    "test": "pnpm lint && pnpm test:types && vitest run --coverage",
+    "test:types": "tsc --noEmit"
+  }
+}

package/.output/server/node_modules/once/once.js

@@ -0,0 +1,42 @@
+var wrappy = require('wrappy')
+module.exports = wrappy(once)
+module.exports.strict = wrappy(onceStrict)
+
+once.proto = once(function () {
+  Object.defineProperty(Function.prototype, 'once', {
+    value: function () {
+      return once(this)
+    },
+    configurable: true
+  })
+
+  Object.defineProperty(Function.prototype, 'onceStrict', {
+    value: function () {
+      return onceStrict(this)
+    },
+    configurable: true
+  })
+})
+
+function once (fn) {
+  var f = function () {
+    if (f.called) return f.value
+    f.called = true
+    return f.value = fn.apply(this, arguments)
+  }
+  f.called = false
+  return f
+}
+
+function onceStrict (fn) {
+  var f = function () {
+    if (f.called)
+      throw new Error(f.onceError)
+    f.called = true
+    return f.value = fn.apply(this, arguments)
+  }
+  var name = fn.name || 'Function wrapped with `once`'
+  f.onceError = name + " shouldn't be called more than once"
+  f.called = false
+  return f
+}

package/.output/server/node_modules/once/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "once",
+  "version": "1.4.0",
+  "description": "Run a function exactly one time",
+  "main": "once.js",
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "wrappy": "1"
+  },
+  "devDependencies": {
+    "tap": "^7.0.1"
+  },
+  "scripts": {
+    "test": "tap test/*.js"
+  },
+  "files": [
+    "once.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/once"
+  },
+  "keywords": [
+    "once",
+    "function",
+    "one",
+    "single"
+  ],
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
+  "license": "ISC"
+}

package/.output/server/node_modules/onetime/index.js

@@ -0,0 +1,44 @@
+'use strict';
+const mimicFn = require('mimic-fn');
+
+const calledFunctions = new WeakMap();
+
+const onetime = (function_, options = {}) => {
+	if (typeof function_ !== 'function') {
+		throw new TypeError('Expected a function');
+	}
+
+	let returnValue;
+	let callCount = 0;
+	const functionName = function_.displayName || function_.name || '<anonymous>';
+
+	const onetime = function (...arguments_) {
+		calledFunctions.set(onetime, ++callCount);
+
+		if (callCount === 1) {
+			returnValue = function_.apply(this, arguments_);
+			function_ = null;
+		} else if (options.throw === true) {
+			throw new Error(`Function \`${functionName}\` can only be called once`);
+		}
+
+		return returnValue;
+	};
+
+	mimicFn(onetime, function_);
+	calledFunctions.set(onetime, callCount);
+
+	return onetime;
+};
+
+module.exports = onetime;
+// TODO: Remove this for the next major release
+module.exports.default = onetime;
+
+module.exports.callCount = function_ => {
+	if (!calledFunctions.has(function_)) {
+		throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+	}
+
+	return calledFunctions.get(function_);
+};

package/.output/server/node_modules/onetime/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "onetime",
+  "version": "5.1.2",
+  "description": "Ensure a function is only called once",
+  "license": "MIT",
+  "repository": "sindresorhus/onetime",
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "engines": {
+    "node": ">=6"
+  },
+  "scripts": {
+    "test": "xo && ava && tsd"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "keywords": [
+    "once",
+    "function",
+    "one",
+    "onetime",
+    "func",
+    "fn",
+    "single",
+    "call",
+    "called",
+    "prevent"
+  ],
+  "dependencies": {
+    "mimic-fn": "^2.1.0"
+  },
+  "devDependencies": {
+    "ava": "^1.4.1",
+    "tsd": "^0.7.1",
+    "xo": "^0.24.0"
+  }
+}

package/.output/server/node_modules/p-cancelable/index.js

@@ -0,0 +1,111 @@
+'use strict';
+
+class CancelError extends Error {
+	constructor(reason) {
+		super(reason || 'Promise was canceled');
+		this.name = 'CancelError';
+	}
+
+	get isCanceled() {
+		return true;
+	}
+}
+
+class PCancelable {
+	static fn(userFn) {
+		return (...arguments_) => {
+			return new PCancelable((resolve, reject, onCancel) => {
+				arguments_.push(onCancel);
+				// eslint-disable-next-line promise/prefer-await-to-then
+				userFn(...arguments_).then(resolve, reject);
+			});
+		};
+	}
+
+	constructor(executor) {
+		this._cancelHandlers = [];
+		this._isPending = true;
+		this._isCanceled = false;
+		this._rejectOnCancel = true;
+
+		this._promise = new Promise((resolve, reject) => {
+			this._reject = reject;
+
+			const onResolve = value => {
+				if (!this._isCanceled || !onCancel.shouldReject) {
+					this._isPending = false;
+					resolve(value);
+				}
+			};
+
+			const onReject = error => {
+				this._isPending = false;
+				reject(error);
+			};
+
+			const onCancel = handler => {
+				if (!this._isPending) {
+					throw new Error('The `onCancel` handler was attached after the promise settled.');
+				}
+
+				this._cancelHandlers.push(handler);
+			};
+
+			Object.defineProperties(onCancel, {
+				shouldReject: {
+					get: () => this._rejectOnCancel,
+					set: boolean => {
+						this._rejectOnCancel = boolean;
+					}
+				}
+			});
+
+			return executor(onResolve, onReject, onCancel);
+		});
+	}
+
+	then(onFulfilled, onRejected) {
+		// eslint-disable-next-line promise/prefer-await-to-then
+		return this._promise.then(onFulfilled, onRejected);
+	}
+
+	catch(onRejected) {
+		return this._promise.catch(onRejected);
+	}
+
+	finally(onFinally) {
+		return this._promise.finally(onFinally);
+	}
+
+	cancel(reason) {
+		if (!this._isPending || this._isCanceled) {
+			return;
+		}
+
+		this._isCanceled = true;
+
+		if (this._cancelHandlers.length > 0) {
+			try {
+				for (const handler of this._cancelHandlers) {
+					handler();
+				}
+			} catch (error) {
+				this._reject(error);
+				return;
+			}
+		}
+
+		if (this._rejectOnCancel) {
+			this._reject(new CancelError(reason));
+		}
+	}
+
+	get isCanceled() {
+		return this._isCanceled;
+	}
+}
+
+Object.setPrototypeOf(PCancelable.prototype, Promise.prototype);
+
+module.exports = PCancelable;
+module.exports.CancelError = CancelError;

package/.output/server/node_modules/p-cancelable/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "p-cancelable",
+  "version": "2.1.1",
+  "description": "Create a promise that can be canceled",
+  "license": "MIT",
+  "repository": "sindresorhus/p-cancelable",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "sindresorhus.com"
+  },
+  "engines": {
+    "node": ">=8"
+  },
+  "scripts": {
+    "test": "xo && ava && tsd"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "keywords": [
+    "promise",
+    "cancelable",
+    "cancel",
+    "canceled",
+    "canceling",
+    "cancellable",
+    "cancellation",
+    "abort",
+    "abortable",
+    "aborting",
+    "cleanup",
+    "task",
+    "token",
+    "async",
+    "function",
+    "await",
+    "promises",
+    "bluebird"
+  ],
+  "devDependencies": {
+    "ava": "^1.4.1",
+    "delay": "^4.1.0",
+    "promise.prototype.finally": "^3.1.0",
+    "tsd": "^0.7.1",
+    "xo": "^0.24.0"
+  }
+}