@synapsync/synk 1.0.0

package/dist/_chunks/libs/is-interactive.mjs

@@ -0,0 +1,4 @@
+function isInteractive({ stream = process.stdout } = {}) {
+	return Boolean(stream && stream.isTTY && process.env.TERM !== "dumb" && !("CI" in process.env));
+}
+export { isInteractive as t };

package/dist/_chunks/libs/is-unicode-supported.mjs

@@ -0,0 +1,8 @@
+import y from "node:process";
+function isUnicodeSupported() {
+	const { env } = y;
+	const { TERM, TERM_PROGRAM } = env;
+	if (y.platform !== "win32") return TERM !== "linux";
+	return Boolean(env.WT_SESSION) || Boolean(env.TERMINUS_SUBLIME) || env.ConEmuTask === "{cmd::Cmder}" || TERM_PROGRAM === "Terminus-Sublime" || TERM_PROGRAM === "vscode" || TERM === "xterm-256color" || TERM === "alacritty" || TERM === "rxvt-unicode" || TERM === "rxvt-unicode-256color" || env.TERMINAL_EMULATOR === "JetBrains-JediTerm";
+}
+export { isUnicodeSupported as t };

package/dist/_chunks/libs/log-symbols.mjs

@@ -0,0 +1,70 @@
+import { t as isUnicodeSupported } from "./is-unicode-supported.mjs";
+import tty from "node:tty";
+const hasColors = tty?.WriteStream?.prototype?.hasColors?.() ?? false;
+const format = (open, close) => {
+	if (!hasColors) return (input) => input;
+	const openCode = `\u001B[${open}m`;
+	const closeCode = `\u001B[${close}m`;
+	return (input) => {
+		const string = input + "";
+		let index = string.indexOf(closeCode);
+		if (index === -1) return openCode + string + closeCode;
+		let result = openCode;
+		let lastIndex = 0;
+		const replaceCode = (close === 22 ? closeCode : "") + openCode;
+		while (index !== -1) {
+			result += string.slice(lastIndex, index) + replaceCode;
+			lastIndex = index + closeCode.length;
+			index = string.indexOf(closeCode, lastIndex);
+		}
+		result += string.slice(lastIndex) + closeCode;
+		return result;
+	};
+};
+format(0, 0);
+format(1, 22);
+format(2, 22);
+format(3, 23);
+format(4, 24);
+format(53, 55);
+format(7, 27);
+format(8, 28);
+format(9, 29);
+format(30, 39);
+const red = format(31, 39);
+const green = format(32, 39);
+const yellow = format(33, 39);
+const blue = format(34, 39);
+format(35, 39);
+format(36, 39);
+format(37, 39);
+format(90, 39);
+format(40, 49);
+format(41, 49);
+format(42, 49);
+format(43, 49);
+format(44, 49);
+format(45, 49);
+format(46, 49);
+format(47, 49);
+format(100, 49);
+format(91, 39);
+format(92, 39);
+format(93, 39);
+format(94, 39);
+format(95, 39);
+format(96, 39);
+format(97, 39);
+format(101, 49);
+format(102, 49);
+format(103, 49);
+format(104, 49);
+format(105, 49);
+format(106, 49);
+format(107, 49);
+const _isUnicodeSupported = isUnicodeSupported();
+const info = blue(_isUnicodeSupported ? "ℹ" : "i");
+const success = green(_isUnicodeSupported ? "✔" : "√");
+const warning = yellow(_isUnicodeSupported ? "⚠" : "‼");
+const error = red(_isUnicodeSupported ? "✖" : "×");
+export { warning as i, info as n, success as r, error as t };

package/dist/_chunks/libs/ora.mjs

@@ -0,0 +1,460 @@
+import { t as source_default } from "./chalk.mjs";
+import { t as cli_cursor_default } from "./cli-cursor.mjs";
+import { t as cli_spinners_default } from "./cli-spinners.mjs";
+import { i as warning, n as info, r as success, t as error } from "./log-symbols.mjs";
+import { t as isUnicodeSupported } from "./is-unicode-supported.mjs";
+import { t as ansiRegex } from "./ansi-regex.mjs";
+import { t as eastAsianWidth } from "./get-east-asian-width.mjs";
+import { t as isInteractive } from "./is-interactive.mjs";
+import y from "node:process";
+import { stripVTControlCharacters } from "node:util";
+const regex = ansiRegex();
+function stripAnsi(string) {
+	if (typeof string !== "string") throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+	return string.replace(regex, "");
+}
+const segmenter = new Intl.Segmenter();
+const zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Mark}|\p{Surrogate})+$/v;
+const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
+const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+function baseVisible(segment) {
+	return segment.replace(leadingNonPrintingRegex, "");
+}
+function isZeroWidthCluster(segment) {
+	return zeroWidthClusterRegex.test(segment);
+}
+function trailingHalfwidthWidth(segment, eastAsianWidthOptions) {
+	let extra = 0;
+	if (segment.length > 1) {
+		for (const char of segment.slice(1)) if (char >= "＀" && char <= "￯") extra += eastAsianWidth(char.codePointAt(0), eastAsianWidthOptions);
+	}
+	return extra;
+}
+function stringWidth(input, options = {}) {
+	if (typeof input !== "string" || input.length === 0) return 0;
+	const { ambiguousIsNarrow = true, countAnsiEscapeCodes = false } = options;
+	let string = input;
+	if (!countAnsiEscapeCodes) string = stripAnsi(string);
+	if (string.length === 0) return 0;
+	let width = 0;
+	const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+	for (const { segment } of segmenter.segment(string)) {
+		if (isZeroWidthCluster(segment)) continue;
+		if (rgiEmojiRegex.test(segment)) {
+			width += 2;
+			continue;
+		}
+		const codePoint = baseVisible(segment).codePointAt(0);
+		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+		width += trailingHalfwidthWidth(segment, eastAsianWidthOptions);
+	}
+	return width;
+}
+const ASCII_ETX_CODE = 3;
+var StdinDiscarder = class {
+	#activeCount = 0;
+	#stdin;
+	#stdinWasPaused = false;
+	#stdinWasRaw = false;
+	#handleInputBound = (chunk) => {
+		if (!chunk?.length) return;
+		if ((typeof chunk === "string" ? chunk.codePointAt(0) : chunk[0]) === ASCII_ETX_CODE) if (y.listenerCount("SIGINT") > 0) y.emit("SIGINT");
+		else y.kill(y.pid, "SIGINT");
+	};
+	start() {
+		this.#activeCount++;
+		if (this.#activeCount === 1) this.#realStart();
+	}
+	stop() {
+		if (this.#activeCount === 0) return;
+		if (--this.#activeCount === 0) this.#realStop();
+	}
+	#realStart() {
+		const { stdin } = y;
+		if (y.platform === "win32" || !stdin?.isTTY || typeof stdin.setRawMode !== "function") {
+			this.#stdin = void 0;
+			return;
+		}
+		this.#stdin = stdin;
+		this.#stdinWasPaused = stdin.isPaused();
+		this.#stdinWasRaw = Boolean(stdin.isRaw);
+		stdin.setRawMode(true);
+		stdin.prependListener("data", this.#handleInputBound);
+		if (this.#stdinWasPaused) stdin.resume();
+	}
+	#realStop() {
+		if (!this.#stdin) return;
+		const stdin = this.#stdin;
+		stdin.off("data", this.#handleInputBound);
+		if (stdin.isTTY) stdin.setRawMode?.(this.#stdinWasRaw);
+		if (this.#stdinWasPaused) stdin.pause();
+		this.#stdin = void 0;
+		this.#stdinWasPaused = false;
+		this.#stdinWasRaw = false;
+	}
+};
+const stdinDiscarder = new StdinDiscarder();
+var stdin_discarder_default = Object.freeze(stdinDiscarder);
+const RENDER_DEFERRAL_TIMEOUT = 200;
+const SYNCHRONIZED_OUTPUT_ENABLE = "\x1B[?2026h";
+const SYNCHRONIZED_OUTPUT_DISABLE = "\x1B[?2026l";
+const activeHooksPerStream = /* @__PURE__ */ new Map();
+var Ora = class {
+	#linesToClear = 0;
+	#frameIndex = -1;
+	#lastFrameTime = 0;
+	#options;
+	#spinner;
+	#stream;
+	#id;
+	#hookedStreams = /* @__PURE__ */ new Map();
+	#isInternalWrite = false;
+	#drainHandler;
+	#deferRenderTimer;
+	#isDiscardingStdin = false;
+	color;
+	#internalWrite(fn) {
+		this.#isInternalWrite = true;
+		try {
+			return fn();
+		} finally {
+			this.#isInternalWrite = false;
+		}
+	}
+	#tryRender() {
+		if (this.isSpinning) this.render();
+	}
+	#stringifyChunk(chunk, encoding) {
+		if (chunk === void 0 || chunk === null) return "";
+		if (typeof chunk === "string") return chunk;
+		if (Buffer.isBuffer(chunk) || ArrayBuffer.isView(chunk)) {
+			const normalizedEncoding = typeof encoding === "string" && encoding && encoding !== "buffer" ? encoding : "utf8";
+			return Buffer.from(chunk).toString(normalizedEncoding);
+		}
+		return String(chunk);
+	}
+	#chunkTerminatesLine(chunkString) {
+		if (!chunkString) return false;
+		const lastCharacter = chunkString.at(-1);
+		return lastCharacter === "\n" || lastCharacter === "\r";
+	}
+	#scheduleRenderDeferral() {
+		if (this.#deferRenderTimer) return;
+		this.#deferRenderTimer = setTimeout(() => {
+			this.#deferRenderTimer = void 0;
+			if (this.isSpinning) this.#tryRender();
+		}, RENDER_DEFERRAL_TIMEOUT);
+		if (typeof this.#deferRenderTimer?.unref === "function") this.#deferRenderTimer.unref();
+	}
+	#clearRenderDeferral() {
+		if (this.#deferRenderTimer) {
+			clearTimeout(this.#deferRenderTimer);
+			this.#deferRenderTimer = void 0;
+		}
+	}
+	#buildOutputLine(symbol, text, prefixText, suffixText) {
+		const fullPrefixText = this.#getFullPrefixText(prefixText, " ");
+		const fullText = typeof text === "string" ? (symbol ? " " : "") + text : "";
+		const fullSuffixText = this.#getFullSuffixText(suffixText, " ");
+		return fullPrefixText + symbol + fullText + fullSuffixText;
+	}
+	constructor(options) {
+		if (typeof options === "string") options = { text: options };
+		this.#options = {
+			color: "cyan",
+			stream: y.stderr,
+			discardStdin: true,
+			hideCursor: true,
+			...options
+		};
+		this.color = this.#options.color;
+		this.#stream = this.#options.stream;
+		if (typeof this.#options.isEnabled !== "boolean") this.#options.isEnabled = isInteractive({ stream: this.#stream });
+		if (typeof this.#options.isSilent !== "boolean") this.#options.isSilent = false;
+		const userInterval = this.#options.interval;
+		this.spinner = this.#options.spinner;
+		this.#options.interval = userInterval;
+		this.text = this.#options.text;
+		this.prefixText = this.#options.prefixText;
+		this.suffixText = this.#options.suffixText;
+		this.indent = this.#options.indent;
+		if (y.env.NODE_ENV === "test") {
+			this._stream = this.#stream;
+			this._isEnabled = this.#options.isEnabled;
+			Object.defineProperty(this, "_linesToClear", {
+				get() {
+					return this.#linesToClear;
+				},
+				set(newValue) {
+					this.#linesToClear = newValue;
+				}
+			});
+			Object.defineProperty(this, "_frameIndex", { get() {
+				return this.#frameIndex;
+			} });
+			Object.defineProperty(this, "_lineCount", { get() {
+				const columns = this.#stream.columns ?? 80;
+				const prefixText = typeof this.#options.prefixText === "function" ? "" : this.#options.prefixText;
+				const suffixText = typeof this.#options.suffixText === "function" ? "" : this.#options.suffixText;
+				const fullPrefixText = typeof prefixText === "string" && prefixText !== "" ? prefixText + " " : "";
+				const fullSuffixText = typeof suffixText === "string" && suffixText !== "" ? " " + suffixText : "";
+				const fullText = " ".repeat(this.#options.indent) + fullPrefixText + "-" + (typeof this.#options.text === "string" ? " " + this.#options.text : "") + fullSuffixText;
+				return this.#computeLineCountFrom(fullText, columns);
+			} });
+		}
+	}
+	get indent() {
+		return this.#options.indent;
+	}
+	set indent(indent = 0) {
+		if (!(indent >= 0 && Number.isInteger(indent))) throw new Error("The `indent` option must be an integer from 0 and up");
+		this.#options.indent = indent;
+	}
+	get interval() {
+		return this.#options.interval ?? this.#spinner.interval ?? 100;
+	}
+	get spinner() {
+		return this.#spinner;
+	}
+	set spinner(spinner) {
+		this.#frameIndex = -1;
+		this.#options.interval = void 0;
+		if (typeof spinner === "object") {
+			if (!Array.isArray(spinner.frames) || spinner.frames.length === 0 || spinner.frames.some((frame) => typeof frame !== "string")) throw new Error("The given spinner must have a non-empty `frames` array of strings");
+			if (spinner.interval !== void 0 && !(Number.isInteger(spinner.interval) && spinner.interval > 0)) throw new Error("`spinner.interval` must be a positive integer if provided");
+			this.#spinner = spinner;
+		} else if (!isUnicodeSupported()) this.#spinner = cli_spinners_default.line;
+		else if (spinner === void 0) this.#spinner = cli_spinners_default.dots;
+		else if (spinner !== "default" && cli_spinners_default[spinner]) this.#spinner = cli_spinners_default[spinner];
+		else throw new Error(`There is no built-in spinner named '${spinner}'. See https://github.com/sindresorhus/cli-spinners/blob/main/spinners.json for a full list.`);
+	}
+	get text() {
+		return this.#options.text;
+	}
+	set text(value = "") {
+		this.#options.text = value;
+	}
+	get prefixText() {
+		return this.#options.prefixText;
+	}
+	set prefixText(value = "") {
+		this.#options.prefixText = value;
+	}
+	get suffixText() {
+		return this.#options.suffixText;
+	}
+	set suffixText(value = "") {
+		this.#options.suffixText = value;
+	}
+	get isSpinning() {
+		return this.#id !== void 0;
+	}
+	#formatAffix(value, separator, placeBefore = false) {
+		const resolved = typeof value === "function" ? value() : value;
+		if (typeof resolved === "string" && resolved !== "") return placeBefore ? separator + resolved : resolved + separator;
+		return "";
+	}
+	#getFullPrefixText(prefixText = this.#options.prefixText, postfix = " ") {
+		return this.#formatAffix(prefixText, postfix, false);
+	}
+	#getFullSuffixText(suffixText = this.#options.suffixText, prefix = " ") {
+		return this.#formatAffix(suffixText, prefix, true);
+	}
+	#computeLineCountFrom(text, columns) {
+		let count = 0;
+		for (const line of stripVTControlCharacters(text).split("\n")) count += Math.max(1, Math.ceil(stringWidth(line) / columns));
+		return count;
+	}
+	get isEnabled() {
+		return this.#options.isEnabled && !this.#options.isSilent;
+	}
+	set isEnabled(value) {
+		if (typeof value !== "boolean") throw new TypeError("The `isEnabled` option must be a boolean");
+		this.#options.isEnabled = value;
+	}
+	get isSilent() {
+		return this.#options.isSilent;
+	}
+	set isSilent(value) {
+		if (typeof value !== "boolean") throw new TypeError("The `isSilent` option must be a boolean");
+		this.#options.isSilent = value;
+	}
+	frame() {
+		const now = Date.now();
+		if (this.#frameIndex === -1 || now - this.#lastFrameTime >= this.interval) {
+			this.#frameIndex = (this.#frameIndex + 1) % this.#spinner.frames.length;
+			this.#lastFrameTime = now;
+		}
+		const { frames } = this.#spinner;
+		let frame = frames[this.#frameIndex];
+		if (this.color) frame = source_default[this.color](frame);
+		const fullPrefixText = this.#getFullPrefixText(this.#options.prefixText, " ");
+		const fullText = typeof this.text === "string" ? " " + this.text : "";
+		const fullSuffixText = this.#getFullSuffixText(this.#options.suffixText, " ");
+		return fullPrefixText + frame + fullText + fullSuffixText;
+	}
+	clear() {
+		if (!this.isEnabled || !this.#stream.isTTY) return this;
+		this.#internalWrite(() => {
+			this.#stream.cursorTo(0);
+			for (let index = 0; index < this.#linesToClear; index++) {
+				if (index > 0) this.#stream.moveCursor(0, -1);
+				this.#stream.clearLine(1);
+			}
+			if (this.#options.indent) this.#stream.cursorTo(this.#options.indent);
+		});
+		this.#linesToClear = 0;
+		return this;
+	}
+	#hookStream(stream) {
+		if (!stream || this.#hookedStreams.has(stream) || !stream.isTTY || typeof stream.write !== "function") return;
+		if (activeHooksPerStream.has(stream)) console.warn("[ora] Multiple concurrent spinners detected. This may cause visual corruption. Use one spinner at a time.");
+		const originalWrite = stream.write;
+		this.#hookedStreams.set(stream, originalWrite);
+		activeHooksPerStream.set(stream, this);
+		stream.write = (chunk, encoding, callback) => this.#hookedWrite(stream, originalWrite, chunk, encoding, callback);
+	}
+	#installHook() {
+		if (!this.isEnabled || this.#hookedStreams.size > 0) return;
+		const streamsToHook = new Set([
+			this.#stream,
+			y.stdout,
+			y.stderr
+		]);
+		for (const stream of streamsToHook) this.#hookStream(stream);
+	}
+	#uninstallHook() {
+		for (const [stream, originalWrite] of this.#hookedStreams) {
+			stream.write = originalWrite;
+			if (activeHooksPerStream.get(stream) === this) activeHooksPerStream.delete(stream);
+		}
+		this.#hookedStreams.clear();
+	}
+	#hookedWrite(stream, originalWrite, chunk, encoding, callback) {
+		if (typeof encoding === "function") {
+			callback = encoding;
+			encoding = void 0;
+		}
+		if (this.#isInternalWrite) return originalWrite.call(stream, chunk, encoding, callback);
+		this.clear();
+		const chunkString = this.#stringifyChunk(chunk, encoding);
+		const chunkTerminatesLine = this.#chunkTerminatesLine(chunkString);
+		const writeResult = originalWrite.call(stream, chunk, encoding, callback);
+		if (chunkTerminatesLine) this.#clearRenderDeferral();
+		else if (chunkString.length > 0) this.#scheduleRenderDeferral();
+		if (this.isSpinning && !this.#deferRenderTimer) this.render();
+		return writeResult;
+	}
+	render() {
+		if (!this.isEnabled || this.#drainHandler || this.#deferRenderTimer) return this;
+		const useSynchronizedOutput = this.#stream.isTTY;
+		let shouldDisableSynchronizedOutput = false;
+		try {
+			if (useSynchronizedOutput) {
+				this.#internalWrite(() => this.#stream.write(SYNCHRONIZED_OUTPUT_ENABLE));
+				shouldDisableSynchronizedOutput = true;
+			}
+			this.clear();
+			let frameContent = this.frame();
+			const columns = this.#stream.columns ?? 80;
+			const actualLineCount = this.#computeLineCountFrom(frameContent, columns);
+			const consoleHeight = this.#stream.rows;
+			if (consoleHeight && consoleHeight > 1 && actualLineCount > consoleHeight) {
+				const lines = frameContent.split("\n");
+				const maxLines = consoleHeight - 1;
+				frameContent = [...lines.slice(0, maxLines), "... (content truncated to fit terminal)"].join("\n");
+			}
+			if (this.#internalWrite(() => this.#stream.write(frameContent)) === false && this.#stream.isTTY) {
+				this.#drainHandler = () => {
+					this.#drainHandler = void 0;
+					this.#tryRender();
+				};
+				this.#stream.once("drain", this.#drainHandler);
+			}
+			this.#linesToClear = this.#computeLineCountFrom(frameContent, columns);
+		} finally {
+			if (shouldDisableSynchronizedOutput) this.#internalWrite(() => this.#stream.write(SYNCHRONIZED_OUTPUT_DISABLE));
+		}
+		return this;
+	}
+	start(text) {
+		if (text) this.text = text;
+		if (this.isSilent) return this;
+		if (!this.isEnabled) {
+			const symbol = this.text ? "-" : "";
+			const line = " ".repeat(this.#options.indent) + this.#buildOutputLine(symbol, this.text, this.#options.prefixText, this.#options.suffixText);
+			if (line.trim() !== "") this.#internalWrite(() => this.#stream.write(line + "\n"));
+			return this;
+		}
+		if (this.isSpinning) return this;
+		if (this.#options.hideCursor) cli_cursor_default.hide(this.#stream);
+		if (this.#options.discardStdin && y.stdin.isTTY) {
+			stdin_discarder_default.start();
+			this.#isDiscardingStdin = true;
+		}
+		this.#installHook();
+		this.render();
+		this.#id = setInterval(this.render.bind(this), this.interval);
+		return this;
+	}
+	stop() {
+		clearInterval(this.#id);
+		this.#id = void 0;
+		this.#frameIndex = -1;
+		this.#lastFrameTime = 0;
+		this.#clearRenderDeferral();
+		this.#uninstallHook();
+		if (this.#drainHandler) {
+			this.#stream.removeListener("drain", this.#drainHandler);
+			this.#drainHandler = void 0;
+		}
+		if (this.isEnabled) {
+			this.clear();
+			if (this.#options.hideCursor) cli_cursor_default.show(this.#stream);
+		}
+		if (this.#isDiscardingStdin) {
+			this.#isDiscardingStdin = false;
+			stdin_discarder_default.stop();
+		}
+		return this;
+	}
+	succeed(text) {
+		return this.stopAndPersist({
+			symbol: success,
+			text
+		});
+	}
+	fail(text) {
+		return this.stopAndPersist({
+			symbol: error,
+			text
+		});
+	}
+	warn(text) {
+		return this.stopAndPersist({
+			symbol: warning,
+			text
+		});
+	}
+	info(text) {
+		return this.stopAndPersist({
+			symbol: info,
+			text
+		});
+	}
+	stopAndPersist(options = {}) {
+		if (this.isSilent) return this;
+		const symbol = options.symbol ?? " ";
+		const text = options.text ?? this.text;
+		const prefixText = options.prefixText ?? this.#options.prefixText;
+		const suffixText = options.suffixText ?? this.#options.suffixText;
+		const textToWrite = this.#buildOutputLine(symbol, text, prefixText, suffixText) + "\n";
+		this.stop();
+		this.#internalWrite(() => this.#stream.write(textToWrite));
+		return this;
+	}
+};
+function ora(options) {
+	return new Ora(options);
+}
+export { ora as t };