@arkebcacy/beacon-cli-temp 0.1.1

package/src/ui/option/jsonRtePlugin.ts

@@ -0,0 +1,16 @@
+import { Option } from 'commander';
+import type Options from '../Options.js';
+import mapParser from '../parser/mapParser.js';
+
+const jsonRtePlugin = new Option(
+	'--json-rte-plugin [name:uid...]',
+	'Map a named JSON RTE Plugin to a stack-specific UID.',
+);
+
+jsonRtePlugin.env('Beacon_Plugin').argParser(mapParser);
+
+export interface JsonRtePluginOption {
+	readonly jsonRtePlugin?: Options['schema']['jsonRtePlugin'] | undefined;
+}
+
+export default jsonRtePlugin;

package/src/ui/option/managementToken.ts

@@ -0,0 +1,18 @@
+import { Option } from 'commander';
+import type Options from '../Options.js';
+import noEmptyStringsFor from '../parser/noEmptyStringsFor.js';
+
+const managementToken = new Option(
+	'--management-token [token]',
+	'Contentstack management token',
+);
+
+managementToken
+	.env('Contentstack_Management_Token')
+	.argParser(noEmptyStringsFor('Management token'));
+
+export interface ManagementTokenOption {
+	readonly managementToken: Options['client']['managementToken'];
+}
+
+export default managementToken;

package/src/ui/option/schemaPath.ts

@@ -0,0 +1,20 @@
+import { Option } from 'commander';
+import { resolve } from 'node:path';
+import type Options from '../Options.js';
+
+const schemaPath = new Option(
+	'--schema-path <path>',
+	'Output Contentstack schema files to the provided folder.',
+);
+
+export const defaultValue = './cs/schema';
+
+schemaPath
+	.default(defaultValue)
+	.argParser((path) => resolve(path ? path : defaultValue));
+
+export interface SchemaPathOption {
+	readonly schemaPath: Options['schema']['schemaPath'];
+}
+
+export default schemaPath;

package/src/ui/option/verbose.ts

@@ -0,0 +1,10 @@
+import { Option } from 'commander';
+import type Options from '../Options.js';
+
+const verbose = new Option('--verbose', 'Increase verbosity');
+
+export interface VerboseOption {
+	readonly verbose?: Options['verbose'] | undefined;
+}
+
+export default verbose;

package/src/ui/parser/mapParser.ts

@@ -0,0 +1,47 @@
+import { InvalidArgumentError } from 'commander';
+
+const formatMsg = 'Extension must be in the form of name:uid';
+
+interface ExtensionMaps {
+	readonly byName: Map<string, string>;
+	readonly byUid: Map<string, string>;
+}
+
+// When specified from the command line, such as:
+//
+//   beacon --extension a:b c:d
+//
+// Each value is passed in one-at-a-time, so `value` is first `a:b`, then
+// argParser is called a second time with `c:d`.
+//
+// When passed as an environment variable, such as:
+//
+//   Beacon_Extension=a:b c:d
+//
+// The entire value is passed at once, so `value` is `a:b c:d`.
+export default function mapParser(
+	value: string,
+	previous?: ExtensionMaps,
+): ExtensionMaps {
+	const byName = previous?.byName ?? new Map<string, string>();
+	const byUid = previous?.byUid ?? new Map<string, string>();
+
+	for (const part of value.split(' ')) {
+		const opts = part.split(':');
+
+		const expectedLength = ['name', 'value'].length;
+		if (opts.length !== expectedLength) {
+			throw new InvalidArgumentError(formatMsg);
+		}
+
+		const [name, uid] = opts;
+		if (typeof name !== 'string' || typeof uid !== 'string') {
+			throw new InvalidArgumentError(formatMsg);
+		}
+
+		byName.set(name, uid);
+		byUid.set(uid, name);
+	}
+
+	return { byName, byUid };
+}

package/src/ui/parser/noEmptyStringsFor.ts

@@ -0,0 +1,12 @@
+import { InvalidArgumentError } from 'commander';
+
+// makeOptionMandatory allows empty string to pass.
+export default function noEmptyStringsFor(name: string) {
+	return (value: string) => {
+		if (value) {
+			return value;
+		}
+
+		throw new InvalidArgumentError(`${name} is required`);
+	};
+}

package/src/ui/progress/Payload.ts

@@ -0,0 +1,38 @@
+import isRecord from '#cli/util/isRecord.js';
+
+export default interface Payload {
+	readonly action?: string | undefined;
+	readonly elapsedMs?: number | undefined;
+	readonly key?: string | undefined;
+	readonly name: string;
+}
+
+export function isPayload(payload: unknown): payload is Payload {
+	if (!isRecord(payload) || typeof payload.name !== 'string') {
+		return false;
+	}
+
+	if ('action' in payload) {
+		if (!isOptional('string')(payload.action)) {
+			return false;
+		}
+	}
+
+	if ('elapsedMs' in payload) {
+		if (!isOptional('number')(payload.elapsedMs)) {
+			return false;
+		}
+	}
+
+	if ('key' in payload) {
+		if (!isOptional('string')(payload.key)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+function isOptional(type: 'number' | 'string') {
+	return (value: unknown) => typeof value === type || value === undefined;
+}

package/src/ui/progress/ProgressBar.ts

@@ -0,0 +1,6 @@
+import type Payload from './Payload.js';
+
+export default interface ProgressBar extends Disposable {
+	increment(step?: number): void;
+	update(payload: Omit<Payload, 'name'>): void;
+}

package/src/ui/progress/ProgressReporter.ts

@@ -0,0 +1,40 @@
+import type ProgressBar from './ProgressBar.js';
+
+const oneSecond = 1000;
+
+export default class ProgressReporter implements Disposable {
+	readonly #start = performance.now();
+	readonly #timer = setInterval(() => this.#report(), oneSecond);
+	#disposed = false;
+
+	public constructor(
+		private readonly bar: ProgressBar,
+		private readonly presentTense: string,
+		private readonly key: string,
+	) {}
+
+	[Symbol.dispose]() {
+		if (!this.#disposed) {
+			clearInterval(this.#timer);
+			this.#disposed = true;
+		}
+	}
+
+	finish(pastTense: string) {
+		this[Symbol.dispose]();
+
+		this.bar.update({
+			action: pastTense,
+			elapsedMs: performance.now() - this.#start,
+			key: this.key,
+		});
+	}
+
+	#report() {
+		this.bar.update({
+			action: this.presentTense,
+			elapsedMs: performance.now() - this.#start,
+			key: this.key,
+		});
+	}
+}

package/src/ui/progress/StyledText.ts

@@ -0,0 +1,4 @@
+export default interface StyledText {
+	readonly value: string;
+	readonly visibleLength: number;
+}

package/src/ui/progress/UiProgressBar.ts

@@ -0,0 +1,35 @@
+import type { MultiBar, SingleBar } from 'cli-progress';
+import type Payload from './Payload.js';
+import type ProgressBar from './ProgressBar.js';
+
+export default class UiProgressBar implements ProgressBar {
+	readonly #bar: SingleBar;
+
+	public constructor(
+		private readonly name: string,
+		container: MultiBar,
+		total: number,
+	) {
+		this.#bar = container.create(total, 0, { name });
+	}
+
+	increment(step?: number): void {
+		this.#bar.increment(step);
+	}
+
+	update(payload: Payload): void {
+		this.#bar.update(payload);
+	}
+
+	[Symbol.dispose](): void {
+		this.#bar.update({
+			action: undefined,
+			elapsedMs: undefined,
+			key: undefined,
+			name: this.name,
+		});
+
+		this.#bar.render();
+		this.#bar.stop();
+	}
+}

package/src/ui/progress/VerboseProgressBar.ts

@@ -0,0 +1,74 @@
+import type { ConsoleUiContext } from '#cli/ui/UiContext.js';
+import formatAction from './formatAction.js';
+import formatCounter from './formatCounter.js';
+import formatElapsed from './formatElapsed.js';
+import formatName from './formatName.js';
+import type Payload from './Payload.js';
+import type ProgressBar from './ProgressBar.js';
+import type StyledText from './StyledText.js';
+
+export default class VerboseProgressBar implements ProgressBar {
+	#current = 0;
+
+	public constructor(
+		private readonly ui: ConsoleUiContext,
+		private readonly name: string,
+		private readonly total: number,
+	) {}
+
+	increment(step?: number): void {
+		this.#current += step ?? 1;
+	}
+
+	update(payload: Payload): void {
+		const name = padEnd(formatName(this.name), this.ui.maxProgressNameLength);
+
+		const counter = formatCounter(this.ui, {
+			total: this.total,
+			value: this.#current,
+		}).value;
+
+		const elapsed = formatElapsed(payload.elapsedMs);
+
+		this.ui.maxElapsedLength = Math.max(
+			this.ui.maxElapsedLength,
+			elapsed.visibleLength,
+		);
+
+		const paddedElapsed =
+			elapsed.value.length > 0
+				? padStart(elapsed, this.ui.maxElapsedLength).value
+				: '';
+
+		this.ui.info(
+			...[
+				name.value,
+				`(${counter}):`,
+				paddedElapsed,
+				formatAction(payload).value,
+			].filter(Boolean),
+		);
+	}
+
+	[Symbol.dispose](): void {
+		// no-op
+	}
+}
+
+function padEnd(text: StyledText, length: number): StyledText {
+	if (text.visibleLength >= length || !Number.isFinite(length)) {
+		return text;
+	}
+
+	const paddedValue = text.value + ' '.repeat(length - text.visibleLength);
+	return { value: paddedValue, visibleLength: length };
+}
+
+function padStart(text: StyledText, length: number): StyledText {
+	if (text.visibleLength >= length || !Number.isFinite(length)) {
+		return text;
+	}
+
+	const paddedValue = ' '.repeat(length - text.visibleLength) + text.value;
+	return { value: paddedValue, visibleLength: length };
+}

package/src/ui/progress/createEmitter.ts

@@ -0,0 +1,24 @@
+import type { ConsoleUiContext } from '#cli/ui/UiContext.js';
+import { inspect } from 'node:util';
+
+export default function createEmitter(
+	ui: ConsoleUiContext,
+	level: 'error' | 'info' | 'warn',
+) {
+	return (message: unknown, ...optionalParams: unknown[]) => {
+		const container = ui.barContainer;
+
+		if (ui.options.verbose || !container) {
+			console[level](message, ...optionalParams);
+			return;
+		}
+
+		const raw = [message, ...optionalParams]
+			.map((o) => (typeof o === 'string' ? o : inspect(o, { colors: true })))
+			.join(' ');
+
+		const end = raw.endsWith('\n') ? '' : '\n';
+
+		container.log(`${raw}${end}`);
+	};
+}

package/src/ui/progress/formatAction.ts

@@ -0,0 +1,20 @@
+import { styleText } from 'node:util';
+import type Payload from './Payload.js';
+import type StyledText from './StyledText.js';
+
+export default function formatAction(
+	{ action, key }: Payload,
+	availableWidth = Infinity,
+): StyledText {
+	if (!(action && key)) {
+		return { value: '', visibleLength: 0 };
+	}
+
+	const visibleLength = action.length + key.length + 1;
+	if (availableWidth < visibleLength) {
+		return { value: '', visibleLength: 0 };
+	}
+
+	const value = `${styleText('cyanBright', action)} ${styleText('cyan', key)}`;
+	return { value, visibleLength };
+}

package/src/ui/progress/formatCounter.ts

@@ -0,0 +1,23 @@
+import type { ConsoleUiContext } from '#cli/ui/UiContext.js';
+import type { Params } from 'cli-progress';
+import { styleText } from 'node:util';
+import type StyledText from './StyledText.js';
+
+export default function formatCounter(
+	{ maxTotalLength }: ConsoleUiContext,
+	params: Pick<Params, 'total' | 'value'>,
+): StyledText {
+	const current = params.value.toLocaleString().padStart(maxTotalLength);
+	const total = params.total.toLocaleString().padStart(maxTotalLength);
+	const sep = ' / ';
+
+	const value = [
+		styleText('yellowBright', current),
+		styleText('dim', sep),
+		styleText('yellowBright', total),
+	].join('');
+
+	const visibleLength = current.length + sep.length + total.length;
+
+	return { value, visibleLength };
+}

package/src/ui/progress/formatElapsed.ts

@@ -0,0 +1,20 @@
+import { styleText } from 'node:util';
+import type StyledText from './StyledText.js';
+
+const formater = new Intl.NumberFormat(undefined, {
+	maximumFractionDigits: 0,
+	minimumFractionDigits: 0,
+	style: 'unit',
+	unit: 'millisecond',
+	unitDisplay: 'short',
+});
+
+export default function formatElapsed(ms: number | undefined): StyledText {
+	if (typeof ms !== 'number') {
+		return { value: '', visibleLength: 0 };
+	}
+
+	const human = formater.format(ms);
+	const value = styleText('dim', human);
+	return { value, visibleLength: human.length };
+}

package/src/ui/progress/formatName.ts

@@ -0,0 +1,14 @@
+import { styleText } from 'node:util';
+import type StyledText from './StyledText.js';
+
+export default function formatName(
+	name: string,
+	availableWidth = Infinity,
+): StyledText {
+	const visibleLength = name.length;
+	if (availableWidth < visibleLength) {
+		return { value: '', visibleLength: 0 };
+	}
+
+	return { value: styleText('yellowBright', name), visibleLength };
+}

package/src/ui/progress/formatProgress.ts

@@ -0,0 +1,67 @@
+import type { ConsoleUiContext } from '#cli/ui/UiContext.js';
+import type { GenericFormatter, Params } from 'cli-progress';
+import { styleText } from 'node:util';
+import formatAction from './formatAction.js';
+import formatCounter from './formatCounter.js';
+import formatName from './formatName.js';
+import type Payload from './Payload.js';
+import { isPayload } from './Payload.js';
+import type StyledText from './StyledText.js';
+
+export default function formatProgress(
+	ui: ConsoleUiContext,
+	...args: Parameters<GenericFormatter>
+) {
+	const [, params] = args;
+	const payload = args[2] as unknown;
+
+	if (!isPayload(payload)) {
+		throw new TypeError('Invalid payload');
+	}
+
+	return [...components(ui, params, payload)].filter(Boolean).join(' ');
+}
+
+function* components(ui: ConsoleUiContext, params: Params, payload: Payload) {
+	let remaining = process.stdout.columns || Infinity;
+
+	const counter = formatCounter(ui, params);
+	yield counter.value;
+	remaining -= counter.visibleLength + 1;
+
+	const bar = formatBar(params, remaining);
+	if (bar.value) {
+		yield bar.value;
+		remaining -= bar.visibleLength + 1;
+	}
+
+	const name = formatName(payload.name, remaining);
+	if (name.value) {
+		yield name.value;
+		remaining -= name.visibleLength + 1;
+	}
+
+	yield formatAction(payload, remaining).value;
+}
+
+function formatBar(params: Params, availableWidth: number): StyledText {
+	const openGlyph = '[';
+	const closeGlyph = ']';
+	const barWidth = 40;
+	const visibleLength = openGlyph.length + barWidth + closeGlyph.length;
+
+	if (availableWidth < visibleLength) {
+		return { value: '', visibleLength: 0 };
+	}
+
+	const completeWidth = Math.round(params.progress * barWidth);
+	const remainingWidth = barWidth - completeWidth;
+
+	const open = styleText('dim', openGlyph);
+	const complete = styleText('greenBright', '█'.repeat(completeWidth));
+	const remaining = styleText('green', '░'.repeat(remainingWidth));
+	const close = styleText('dim', closeGlyph);
+	const value = `${open}${complete}${remaining}${close}`;
+
+	return { value, visibleLength };
+}

package/src/ui/version.ts

@@ -0,0 +1,24 @@
+import isRecord from '#cli/util/isRecord.js';
+import { readFile } from 'node:fs/promises';
+
+export default async function version() {
+	try {
+		const packageUrl = new URL('../../package.json', import.meta.url);
+		const rawPackage = await readFile(packageUrl, 'utf8');
+		const packageJson = JSON.parse(rawPackage) as unknown;
+
+		if (!isRecord(packageJson)) {
+			throw new Error('package.json is not an object');
+		}
+
+		const { version: result } = packageJson;
+
+		if (typeof result !== 'string') {
+			throw new Error('version is not a string');
+		}
+
+		return result;
+	} catch {
+		return 'unknown';
+	}
+}

package/src/util/OmitIndex.ts

@@ -0,0 +1,8 @@
+type OmitIndex<T> = {
+	// Justification: This is used to remove an index signature from an object
+	// type, and the {} is needed instead of `unknown` or `object`.
+	// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+	[K in keyof T as {} extends Record<K, 1> ? never : K]: T[K];
+};
+
+export default OmitIndex;

package/src/util/escapeRegex.ts

@@ -0,0 +1,17 @@
+/**
+ * Escapes special regular expression characters in a string.
+ *
+ * This function makes a string safe to use as a literal pattern in a RegExp constructor
+ * by escaping all characters that have special meaning in regular expressions.
+ *
+ * @param str - The string to escape
+ * @returns The escaped string safe for use in a RegExp pattern
+ *
+ * @example
+ * const filename = 'My.Entry.Title';
+ * const pattern = new RegExp(`^${escapeRegex(filename)}\\.yaml$`, 'u');
+ * // Creates pattern: /^My\.Entry\.Title\.yaml$/u
+ */
+export default function escapeRegex(str: string): string {
+	return str.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}

package/src/util/isRecord.ts

@@ -0,0 +1,3 @@
+export default function isRecord(o: unknown): o is Record<string, unknown> {
+	return o !== null && typeof o === 'object';
+}