@shell-shock/core 0.2.0 → 0.2.1

package/dist/components/utils-builtin.mjs

@@ -0,0 +1,447 @@
+import defu$1 from "defu";
+import { createComponent, createIntrinsic, mergeProps } from "@alloy-js/core/jsx-runtime";
+import { Show, code, splitProps } from "@alloy-js/core";
+import { FunctionDeclaration, InterfaceDeclaration, InterfaceMember, VarDeclaration } from "@alloy-js/typescript";
+import { BuiltinFile } from "@powerlines/plugin-alloy/typescript/components/builtin-file";
+import { TSDoc, TSDocLink, TSDocParam, TSDocReturns } from "@powerlines/plugin-alloy/typescript/components/tsdoc";
+
+//#region src/components/utils-builtin.tsx
+/**
+* Generates utilities for detecting terminal color support.
+*/
+function EnvSupportUtilities() {
+	return [
+		createComponent(VarDeclaration, {
+			"export": true,
+			"const": true,
+			name: "isTTY",
+			doc: "Detect if stdout.TTY is available",
+			initializer: code`Boolean(process.stdout && process.stdout.isTTY);`
+		}),
+		createIntrinsic("hbr", {}),
+		createIntrinsic("hbr", {}),
+		createComponent(VarDeclaration, {
+			"export": true,
+			"const": true,
+			name: "isMinimal",
+			doc: "Detect if the current environment is minimal (CI, non-TTY, etc.)",
+			initializer: code` env.MINIMAL || isCI || isTest || !isTTY; `
+		}),
+		createIntrinsic("hbr", {}),
+		createIntrinsic("hbr", {}),
+		createComponent(VarDeclaration, {
+			"export": true,
+			"const": true,
+			name: "isInteractive",
+			doc: "Detect if the current environment is interactive",
+			initializer: code` !isMinimal && process.stdin?.isTTY && env.TERM !== "dumb"; `
+		})
+	];
+}
+/**
+* Generates utilities for detecting terminal color support.
+*/
+function ColorSupportUtilities() {
+	return [
+		createComponent(InterfaceDeclaration, {
+			"export": true,
+			name: "GetColorSupportLevelOptions",
+			doc: "Options for the getColorSupportLevel function",
+			get children() {
+				return createComponent(InterfaceMember, {
+					name: "ignoreFlags",
+					type: "boolean",
+					doc: "Indicates if the function should skip checking command-line flags for color support"
+				});
+			}
+		}),
+		createIntrinsic("hbr", {}),
+		createIntrinsic("hbr", {}),
+		createComponent(TSDoc, {
+			heading: "Checks if a specific flag is present in the command line arguments.",
+			get children() {
+				return [
+					createComponent(TSDocLink, { children: "https://github.com/sindresorhus/has-flag/blob/main/index.js" }),
+					createComponent(TSDocParam, {
+						name: "flag",
+						children: "The flag to check for, e.g., \"color\", \"no-color\"."
+					}),
+					createComponent(TSDocParam, {
+						name: "argv",
+						children: "The command line arguments to check against. Defaults to global Deno args or process args."
+					}),
+					createComponent(TSDocReturns, { children: "True if the flag is present, false otherwise." })
+				];
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			name: "getColorSupportLevel",
+			parameters: [{
+				name: "stream",
+				type: "NodeJS.WriteStream & { fd: 1 | 2; }"
+			}, {
+				name: "options",
+				type: "GetColorSupportLevelOptions",
+				default: "{}"
+			}],
+			children: code`const { ignoreFlags = false } = options;
+
+        let forceColor: number | undefined;
+        if (env.FORCE_COLOR !== undefined) {
+          forceColor = !env.FORCE_COLOR
+            ? 0
+            : typeof env.FORCE_COLOR === "boolean"
+            ? 1
+            : typeof env.FORCE_COLOR === "number" &&
+              [0, 1, 2, 3].includes(Math.min(env.FORCE_COLOR as number, 3))
+            ? Math.min(env.FORCE_COLOR as number, 3)
+            : undefined;
+        }
+
+        if (ignoreFlags !== true && forceColor === undefined) {
+          forceColor = hasFlag("no-color") ||
+            hasFlag("no-colors") ||
+            hasFlag("color=false") ||
+            hasFlag("color=never")
+          ? 0
+          : hasFlag("color") ||
+            hasFlag("colors") ||
+            hasFlag("color=true") ||
+            hasFlag("color=always")
+          ? 1
+          : 0;
+        }
+
+        if (forceColor === 0) {
+          return 0;
+        }
+
+        if (ignoreFlags !== true) {
+          if (hasFlag("color=16m") ||
+            hasFlag("color=full") ||
+            hasFlag("color=truecolor")) {
+            return 3;
+          }
+
+          if (hasFlag("color=256")) {
+            return 2;
+          }
+        }
+
+        const level = Boolean(env.TF_BUILD) || Boolean(env.AGENT_NAME)
+          ? 1
+          : stream &&
+              !(isTTY || (stream && stream.isTTY)) &&
+              forceColor === undefined
+            ? 0
+            : env.TERM === "dumb"
+              ? forceColor || 0
+              : isWindows
+                ? Number(os.release().split(".")[0]) >= 10 &&
+                  Number(os.release().split(".")[2]) >= 10_586
+                  ? Number(os.release().split(".")[2]) >= 14_931
+                    ? 3
+                    : 2
+                  : 1
+                : isCI
+                  ? Boolean(env.GITHUB_ACTIONS) ||
+                    Boolean(env.GITEA_ACTIONS) ||
+                    Boolean(env.CIRCLECI)
+                    ? 3
+                    : Boolean(env.TRAVIS) ||
+                      Boolean(env.APPVEYOR) ||
+                      Boolean(env.GITLAB_CI) ||
+                      Boolean(env.BUILDKITE) ||
+                      Boolean(env.DRONE) ||
+                      env.CI_NAME === "codeship"
+                      ? 1
+                      : forceColor || 0
+                  : Boolean(env.TEAMCITY_VERSION)
+                    ? /^(?:9\.0*[1-9]\d*\.|\d{2,}\.)/.test(String(env.TEAMCITY_VERSION) || "")
+                      ? 1
+                      : 0
+                    : String(env.COLORTERM) === "truecolor" ||
+                        env.TERM === "xterm-kitty"
+                      ? 3
+                      : Boolean(env.TERM_PROGRAM)
+                        ? env.TERM_PROGRAM === "iTerm.app"
+                          ? Number.parseInt(
+                              (env.TERM_PROGRAM_VERSION || "").split(".")[0] as string,
+                              10
+                            ) >= 3
+                            ? 3
+                            : 2
+                          : env.TERM_PROGRAM === "Apple_Terminal"
+                            ? 2
+                            : 0
+                        : /-256(?:color)?$/i.test(env.TERM || "")
+                          ? 2
+                          : /^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(
+                                env.TERM || ""
+                              )
+                            ? 1
+                            : Boolean(env.COLORTERM);
+
+        return typeof level === "boolean" || level === 0
+          ? false
+          : {
+              level,
+              hasBasic: true,
+              has256: level >= 2,
+              has16m: level >= 3,
+            };
+
+  `
+		}),
+		createIntrinsic("hbr", {}),
+		createIntrinsic("hbr", {}),
+		createComponent(VarDeclaration, {
+			"export": true,
+			"const": true,
+			name: "colorSupportLevels",
+			doc: "Detect the terminal color support level in the current environment",
+			initializer: code` {
+    stdout: getColorSupportLevel(process.stdout),
+    stderr: getColorSupportLevel(process.stderr),
+  }; `
+		}),
+		createIntrinsic("hbr", {}),
+		createIntrinsic("hbr", {}),
+		createComponent(VarDeclaration, {
+			"export": true,
+			"const": true,
+			name: "isColorSupported",
+			doc: "Detect if terminal color is supported in the current environment",
+			initializer: code` Boolean(colorSupportLevels.stdout); `
+		}),
+		createIntrinsic("hbr", {}),
+		createIntrinsic("hbr", {}),
+		createComponent(VarDeclaration, {
+			"export": true,
+			"const": true,
+			name: "isUnicodeSupported",
+			doc: "Detect if Unicode characters are supported in the current environment",
+			initializer: code` !isWindows
+            ? env.TERM !== "linux"
+            : Boolean(env.WT_SESSION) ||
+                Boolean(env.TERMINUS_SUBLIME) ||
+                env.ConEmuTask === "{cmd::Cmder}" ||
+                env.TERM_PROGRAM === "Terminus-Sublime" ||
+                env.TERM_PROGRAM === "vscode" ||
+                env.TERM === "xterm-256color" ||
+                env.TERM === "alacritty" ||
+                env.TERM === "rxvt-unicode" ||
+                env.TERM === "rxvt-unicode-256color" ||
+                env.TERMINAL_EMULATOR === "JetBrains-JediTerm"; `
+		})
+	];
+}
+/**
+* Generates utilities for detecting terminal color support.
+*/
+function HyperlinkSupportUtilities() {
+	return [
+		createComponent(FunctionDeclaration, {
+			name: "parseVersion",
+			parameters: [{
+				name: "version",
+				type: "string",
+				default: "\"\""
+			}],
+			children: code`if (/^\d{3,4}$/.test(version)) {
+        const match = /(\d{1,2})(\d{2})/.exec(version) ?? [];
+
+        return {
+          major: 0,
+          minor: Number.parseInt(match[1]!, 10),
+          patch: Number.parseInt(match[2]!, 10)
+        };
+      }
+
+      const versionParts = (version ?? "")
+        .split(".")
+        .map(n => Number.parseInt(n, 10));
+
+      return {
+        major: versionParts[0],
+        minor: versionParts[1],
+        patch: versionParts[2]
+      }; `
+		}),
+		createComponent(TSDoc, {
+			heading: "Check if the current environment/terminal supports hyperlinks in the terminal.",
+			get children() {
+				return createComponent(TSDocReturns, { children: "True if the current environment/terminal supports hyperlinks." });
+			}
+		}),
+		createComponent(FunctionDeclaration, {
+			"export": true,
+			name: "isHyperlinkSupported",
+			returnType: "boolean",
+			children: code`if (Boolean(env.FORCE_HYPERLINK)) {
+          return true;
+        }
+
+        if (Boolean(env.NETLIFY)) {
+          return true;
+        } else if (isColorSupported || isTTY) {
+          return false;
+        } else if (Boolean(env.WT_SESSION)) {
+          return true;
+        } else if (isWindows || isMinimal || Boolean(env.TEAMCITY_VERSION)) {
+          return false;
+        } else if (Boolean(env.TERM_PROGRAM)) {
+          const version = parseVersion(env.TERM_PROGRAM_VERSION);
+
+          switch (String(env.TERM_PROGRAM)) {
+            case "iTerm.app": {
+              if (version.major === 3) {
+                return version.minor !== undefined && version.minor >= 1;
+              }
+
+              return version.major !== undefined && version.major > 3;
+            }
+            case "WezTerm": {
+              return version.major !== undefined && version.major >= 20_200_620;
+            }
+
+            case "vscode": {
+              if (Boolean(env.CURSOR_TRACE_ID)) {
+                return true;
+              }
+
+              return (
+                version.minor !== undefined &&
+                version.major !== undefined &&
+                (version.major > 1 || (version.major === 1 && version.minor >= 72))
+              );
+            }
+
+            case "ghostty": {
+              return true;
+            }
+          }
+        }
+
+        if (Boolean(env.VTE_VERSION)) {
+          if (env.VTE_VERSION === "0.50.0") {
+            return false;
+          }
+
+          const version = parseVersion(env.VTE_VERSION);
+          return (
+            (version.major !== undefined && version.major > 0) ||
+            (version.minor !== undefined && version.minor >= 50)
+          );
+        }
+
+        if (String(env.TERM) === "alacritty") {
+          return true;
+        }
+
+        return false; `
+		})
+	];
+}
+/**
+* Generates utilities for detecting terminal color support.
+*/
+function ArgsUtilities() {
+	return [createComponent(TSDoc, {
+		heading: "Checks if a specific flag is present in the command line arguments.",
+		get children() {
+			return [
+				createComponent(TSDocLink, { children: "https://github.com/sindresorhus/has-flag/blob/main/index.js" }),
+				createComponent(TSDocParam, {
+					name: "flag",
+					children: "The flag (or an array of flags/aliases) to check for, e.g., \"color\", \"no-color\"."
+				}),
+				createComponent(TSDocParam, {
+					name: "argv",
+					children: "The command line arguments to check against. Defaults to global Deno args or process args."
+				}),
+				createComponent(TSDocReturns, { children: "True if the flag is present, false otherwise." })
+			];
+		}
+	}), createComponent(FunctionDeclaration, {
+		"export": true,
+		name: "hasFlag",
+		parameters: [{
+			name: "flag",
+			type: "string | string[]"
+		}, {
+			name: "argv",
+			type: "string[]",
+			optional: true,
+			default: "globalThis.Deno ? globalThis.Deno.args : process.argv"
+		}],
+		get children() {
+			return [
+				createComponent(VarDeclaration, {
+					"const": true,
+					name: "position",
+					type: "number",
+					initializer: code`(Array.isArray(flag) ? flag : [flag]).reduce((ret, f) => {
+            const pos = argv.findIndex(arg => (f.startsWith("-") ? "" : (f.length === 1 ? "-" : "--") + f)?.toLowerCase() === arg?.toLowerCase() || arg?.toLowerCase().startsWith((f.length === 1 ? "-" : "--") + f + "=")?.toLowerCase());
+            return pos !== -1 ? pos : ret;
+          }, -1);`
+				}),
+				createIntrinsic("hbr", {}),
+				code`return position !== -1 && argv.indexOf("--") === -1 || position < argv.indexOf("--");`
+			];
+		}
+	})];
+}
+/**
+* A built-in utilities module for Shell Shock.
+*/
+function UtilsBuiltin(props) {
+	const [{ children }, rest] = splitProps(props, ["children"]);
+	return createComponent(BuiltinFile, mergeProps({
+		id: "utils",
+		description: "A collection of helper utilities that ease command-line application development."
+	}, rest, {
+		get imports() {
+			return defu$1(rest.imports ?? {}, {
+				"node:os": ["os"],
+				"node:process": ["process"]
+			});
+		},
+		get builtinImports() {
+			return defu$1(rest.builtinImports ?? {}, { env: [
+				"env",
+				"isCI",
+				"isTest",
+				"isWindows"
+			] });
+		},
+		get children() {
+			return [
+				createIntrinsic("hbr", {}),
+				createIntrinsic("hbr", {}),
+				createComponent(ArgsUtilities, {}),
+				createIntrinsic("hbr", {}),
+				createIntrinsic("hbr", {}),
+				createComponent(EnvSupportUtilities, {}),
+				createIntrinsic("hbr", {}),
+				createIntrinsic("hbr", {}),
+				createComponent(HyperlinkSupportUtilities, {}),
+				createIntrinsic("hbr", {}),
+				createIntrinsic("hbr", {}),
+				createComponent(ColorSupportUtilities, {}),
+				createIntrinsic("hbr", {}),
+				createIntrinsic("hbr", {}),
+				createComponent(Show, {
+					get when() {
+						return Boolean(children);
+					},
+					children
+				})
+			];
+		}
+	}));
+}
+
+//#endregion
+export { ArgsUtilities, ColorSupportUtilities, EnvSupportUtilities, HyperlinkSupportUtilities, UtilsBuiltin };

package/dist/config.cjs

@@ -1 +1,17 @@
-function e(e){return e}exports.defineConfig=e;
+
+//#region src/config.ts
+/**
+* A utility function to define a Shell Shock user configuration.
+*
+* @remarks
+* This function is used to create a user configuration object for Shell Shock projects. It ensures that the configuration adheres to the expected structure.
+*
+* @param config - A partial user configuration object.
+* @returns A complete user configuration object.
+*/
+function defineConfig(config) {
+	return config;
+}
+
+//#endregion
+exports.defineConfig = defineConfig;

package/dist/config.mjs

@@ -1 +1,16 @@
-function e(e){return e}export{e as defineConfig};
+//#region src/config.ts
+/**
+* A utility function to define a Shell Shock user configuration.
+*
+* @remarks
+* This function is used to create a user configuration object for Shell Shock projects. It ensures that the configuration adheres to the expected structure.
+*
+* @param config - A partial user configuration object.
+* @returns A complete user configuration object.
+*/
+function defineConfig(config) {
+	return config;
+}
+
+//#endregion
+export { defineConfig };

package/dist/helpers/persistence.cjs

@@ -1 +1,49 @@
-const e=require(`../_virtual/rolldown_runtime.cjs`);let t=require(`@stryke/path/join-paths`);function n(e){return(0,t.joinPaths)(e.dataPath,`commands.json`)}function r(e){let t=(e,n=null)=>{let r={...e,parent:n,children:{}};for(let[n,i]of Object.entries(e.children||{}))r.children[n]=t(i,e.id);return r},n={};for(let[r,i]of Object.entries(e))n[r]=t(i,null);return n}function i(e){let t=(e,n=null)=>{let r={...e,parent:n,children:{}};for(let[n,i]of Object.entries(e.children||{}))r.children[n]=t(i,r);return r},n={};for(let[r,i]of Object.entries(e))n[r]=t(i,null);return n}async function a(e){let t=await e.fs.read(n(e));if(!t||!t.length)throw Error(`CLI Command reflection file ${n(e)} is empty`);e.commands=i(JSON.parse(t))}async function o(e){let t=n(e);await e.fs.write(t,JSON.stringify(r(e.commands),null,e.config.mode===`development`?2:0))}exports.getCommandsPersistencePath=n,exports.readCommandsPersistence=a,exports.writeCommandsPersistence=o;
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let __stryke_path_join_paths = require("@stryke/path/join-paths");
+
+//#region src/helpers/persistence.ts
+function getCommandsPersistencePath(context) {
+	return (0, __stryke_path_join_paths.joinPaths)(context.dataPath, `commands.json`);
+}
+function serializedCommandTree(commands) {
+	const serialize = (node, parent = null) => {
+		const serializedNode = {
+			...node,
+			parent,
+			children: {}
+		};
+		for (const [key, child] of Object.entries(node.children || {})) serializedNode.children[key] = serialize(child, node.id);
+		return serializedNode;
+	};
+	const result = {};
+	for (const [key, child] of Object.entries(commands)) result[key] = serialize(child, null);
+	return result;
+}
+function deserializeCommandTree(serializedCommands) {
+	const deserialize = (node, parent = null) => {
+		const deserializedNode = {
+			...node,
+			parent,
+			children: {}
+		};
+		for (const [key, child] of Object.entries(node.children || {})) deserializedNode.children[key] = deserialize(child, deserializedNode);
+		return deserializedNode;
+	};
+	const result = {};
+	for (const [key, child] of Object.entries(serializedCommands)) result[key] = deserialize(child, null);
+	return result;
+}
+async function readCommandsPersistence(context) {
+	const reflections = await context.fs.read(getCommandsPersistencePath(context));
+	if (!reflections || !reflections.length) throw new Error(`CLI Command reflection file ${getCommandsPersistencePath(context)} is empty`);
+	context.commands = deserializeCommandTree(JSON.parse(reflections));
+}
+async function writeCommandsPersistence(context) {
+	const filePath = getCommandsPersistencePath(context);
+	await context.fs.write(filePath, JSON.stringify(serializedCommandTree(context.commands), null, context.config.mode === "development" ? 2 : 0));
+}
+
+//#endregion
+exports.getCommandsPersistencePath = getCommandsPersistencePath;
+exports.readCommandsPersistence = readCommandsPersistence;
+exports.writeCommandsPersistence = writeCommandsPersistence;

package/dist/helpers/persistence.mjs

@@ -1 +1,46 @@
-import{joinPaths as e}from"@stryke/path/join-paths";function t(t){return e(t.dataPath,`commands.json`)}function n(e){let t=(e,n=null)=>{let r={...e,parent:n,children:{}};for(let[n,i]of Object.entries(e.children||{}))r.children[n]=t(i,e.id);return r},n={};for(let[r,i]of Object.entries(e))n[r]=t(i,null);return n}function r(e){let t=(e,n=null)=>{let r={...e,parent:n,children:{}};for(let[n,i]of Object.entries(e.children||{}))r.children[n]=t(i,r);return r},n={};for(let[r,i]of Object.entries(e))n[r]=t(i,null);return n}async function i(e){let n=await e.fs.read(t(e));if(!n||!n.length)throw Error(`CLI Command reflection file ${t(e)} is empty`);e.commands=r(JSON.parse(n))}async function a(e){let r=t(e);await e.fs.write(r,JSON.stringify(n(e.commands),null,e.config.mode===`development`?2:0))}export{t as getCommandsPersistencePath,i as readCommandsPersistence,a as writeCommandsPersistence};
+import { joinPaths } from "@stryke/path/join-paths";
+
+//#region src/helpers/persistence.ts
+function getCommandsPersistencePath(context) {
+	return joinPaths(context.dataPath, `commands.json`);
+}
+function serializedCommandTree(commands) {
+	const serialize = (node, parent = null) => {
+		const serializedNode = {
+			...node,
+			parent,
+			children: {}
+		};
+		for (const [key, child] of Object.entries(node.children || {})) serializedNode.children[key] = serialize(child, node.id);
+		return serializedNode;
+	};
+	const result = {};
+	for (const [key, child] of Object.entries(commands)) result[key] = serialize(child, null);
+	return result;
+}
+function deserializeCommandTree(serializedCommands) {
+	const deserialize = (node, parent = null) => {
+		const deserializedNode = {
+			...node,
+			parent,
+			children: {}
+		};
+		for (const [key, child] of Object.entries(node.children || {})) deserializedNode.children[key] = deserialize(child, deserializedNode);
+		return deserializedNode;
+	};
+	const result = {};
+	for (const [key, child] of Object.entries(serializedCommands)) result[key] = deserialize(child, null);
+	return result;
+}
+async function readCommandsPersistence(context) {
+	const reflections = await context.fs.read(getCommandsPersistencePath(context));
+	if (!reflections || !reflections.length) throw new Error(`CLI Command reflection file ${getCommandsPersistencePath(context)} is empty`);
+	context.commands = deserializeCommandTree(JSON.parse(reflections));
+}
+async function writeCommandsPersistence(context) {
+	const filePath = getCommandsPersistencePath(context);
+	await context.fs.write(filePath, JSON.stringify(serializedCommandTree(context.commands), null, context.config.mode === "development" ? 2 : 0));
+}
+
+//#endregion
+export { getCommandsPersistencePath, readCommandsPersistence, writeCommandsPersistence };