@highstate/designer 0.2.1 → 0.2.2

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

@@ -1,306 +0,0 @@
-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

@@ -1,60 +0,0 @@
-{
-  "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

@@ -1,42 +0,0 @@
-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

@@ -1,33 +0,0 @@
-{
-  "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

@@ -1,44 +0,0 @@
-'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

@@ -1,43 +0,0 @@
-{
-  "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

@@ -1,111 +0,0 @@
-'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

@@ -1,49 +0,0 @@
-{
-  "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"
-  }
-}