t3code-cli 0.13.0 → 0.14.0

package/dist/shared/preview.js

@@ -0,0 +1,103 @@
+import { GT as Defect, JT as Literals, QT as String, ZT as Number, cE as is, eE as TaggedErrorClass, uE as optional } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/preview.ts
+/**
+* Pure URL helpers shared between the preview server, desktop main process,
+* and web renderer. Centralising these guarantees the four call sites agree
+* on what counts as "loopback" and how to normalise a free-form URL string.
+*/
+const TAB_ID_PREFIX = "tab_";
+let nextPreviewTabSequence = 0;
+/**
+* Generate a fresh preview tab id. Lives in shared (not contracts) because
+* the contracts package is schema-only — runtime helpers belong here.
+*/
+function newPreviewTabId() {
+	nextPreviewTabSequence += 1;
+	return `${TAB_ID_PREFIX}${nextPreviewTabSequence.toString(36)}`;
+}
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"localhost",
+	"127.0.0.1",
+	"0.0.0.0",
+	"::1"
+]);
+/** Internal — used by `lsof` parsing where the host string is wire-formatted. */
+const LSOF_LOCAL_HOST_TOKENS = /* @__PURE__ */ new Set([
+	...LOOPBACK_HOSTS,
+	"*",
+	"[::]",
+	"[::1]"
+]);
+const LOOPBACK_PREFIX_PATTERN = /^(?:localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1?\])(?::|\/|$)/i;
+function isLoopbackHost(host) {
+	if (LOOPBACK_HOSTS.has(host)) return true;
+	if (host === "[::1]") return true;
+	return false;
+}
+/** True when a raw URL string looks like a loopback dev URL we can preview. */
+function isPreviewableUrl(rawUrl) {
+	try {
+		const parsed = new URL(rawUrl);
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+		return isLoopbackHost(parsed.hostname);
+	} catch {
+		return false;
+	}
+}
+var PreviewUrlNormalizationError = class extends TaggedErrorClass()("PreviewUrlNormalizationError", {
+	inputLength: Number,
+	reason: Literals([
+		"empty",
+		"parse",
+		"unsupported-protocol"
+	]),
+	protocol: optional(String),
+	cause: optional(Defect())
+}) {
+	get message() {
+		const protocol = this.protocol === void 0 ? "" : `: ${this.protocol}`;
+		return `Invalid preview URL (${this.reason}${protocol}; input length ${this.inputLength}).`;
+	}
+};
+const isPreviewUrlNormalizationError = is(PreviewUrlNormalizationError);
+function previewUrlProtocol(rawUrl) {
+	return /^([A-Za-z][A-Za-z\d+.-]*):/.exec(rawUrl)?.[1]?.toLowerCase().concat(":");
+}
+/**
+* Normalise a free-form URL string into a fully-qualified `http(s)://` URL.
+*
+* - Bare loopback hosts (`localhost`, `localhost:5173`) become `http://...`.
+* - Bare public hosts (`example.com`) become `https://...`.
+* - Already-qualified URLs are validated and returned as `URL.href`.
+*
+* Throws `PreviewUrlNormalizationError` for empty, unparseable, or
+* unsupported-protocol inputs.
+*/
+function normalizePreviewUrl(rawUrl) {
+	const trimmed = rawUrl.trim();
+	if (trimmed.length === 0) throw new PreviewUrlNormalizationError({
+		inputLength: rawUrl.length,
+		reason: "empty"
+	});
+	const useHttp = LOOPBACK_PREFIX_PATTERN.test(trimmed);
+	const candidate = trimmed.includes("://") ? trimmed : `${useHttp ? "http" : "https"}://${trimmed}`;
+	let parsed;
+	try {
+		parsed = new URL(candidate);
+	} catch (cause) {
+		throw new PreviewUrlNormalizationError({
+			inputLength: rawUrl.length,
+			reason: "parse",
+			protocol: previewUrlProtocol(candidate),
+			cause
+		});
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new PreviewUrlNormalizationError({
+		inputLength: rawUrl.length,
+		reason: "unsupported-protocol",
+		protocol: parsed.protocol
+	});
+	return parsed.href;
+}
+//#endregion
+export { LSOF_LOCAL_HOST_TOKENS, PreviewUrlNormalizationError, isLoopbackHost, isPreviewUrlNormalizationError, isPreviewableUrl, newPreviewTabId, normalizePreviewUrl };

package/dist/shared/previewViewport.d.ts

@@ -0,0 +1,16 @@
+import { Gy as PreviewAutomationResizeInput, Nb as PreviewViewportPresetId, Pb as PreviewViewportSetting } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/previewViewport.d.ts
+interface PreviewViewportPreset {
+  readonly id: PreviewViewportPresetId;
+  readonly label: string;
+  readonly category: "Desktop" | "Tablet" | "Phone";
+  readonly detail: string;
+  readonly width: number;
+  readonly height: number;
+}
+declare const PREVIEW_VIEWPORT_PRESETS: ReadonlyArray<PreviewViewportPreset>;
+declare function resolvePreviewViewport(input: PreviewAutomationResizeInput): PreviewViewportSetting;
+declare function previewViewportLabel(viewport: PreviewViewportSetting): string;
+declare function previewViewportPresetOrientation(viewport: PreviewViewportSetting): "portrait" | "landscape" | null;
+//#endregion
+export { PREVIEW_VIEWPORT_PRESETS, PreviewViewportPreset, previewViewportLabel, previewViewportPresetOrientation, resolvePreviewViewport };

package/dist/shared/previewViewport.js

@@ -0,0 +1,159 @@
+import { J_ as PREVIEW_VIEWPORT_PRESET_IDS } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/previewViewport.ts
+const PREVIEW_VIEWPORT_PRESET_DEFINITIONS = {
+	"iphone-se": {
+		label: "iPhone SE",
+		category: "Phone",
+		detail: "375 × 667",
+		width: 375,
+		height: 667
+	},
+	"iphone-xr": {
+		label: "iPhone XR",
+		category: "Phone",
+		detail: "414 × 896",
+		width: 414,
+		height: 896
+	},
+	"iphone-12-pro": {
+		label: "iPhone 12 Pro",
+		category: "Phone",
+		detail: "390 × 844",
+		width: 390,
+		height: 844
+	},
+	"iphone-14-pro-max": {
+		label: "iPhone 14 Pro Max",
+		category: "Phone",
+		detail: "430 × 932",
+		width: 430,
+		height: 932
+	},
+	"pixel-7": {
+		label: "Pixel 7",
+		category: "Phone",
+		detail: "412 × 915",
+		width: 412,
+		height: 915
+	},
+	"samsung-galaxy-s8-plus": {
+		label: "Samsung Galaxy S8+",
+		category: "Phone",
+		detail: "360 × 740",
+		width: 360,
+		height: 740
+	},
+	"samsung-galaxy-s20-ultra": {
+		label: "Samsung Galaxy S20 Ultra",
+		category: "Phone",
+		detail: "412 × 915",
+		width: 412,
+		height: 915
+	},
+	"ipad-mini": {
+		label: "iPad Mini",
+		category: "Tablet",
+		detail: "768 × 1024",
+		width: 768,
+		height: 1024
+	},
+	"ipad-air": {
+		label: "iPad Air",
+		category: "Tablet",
+		detail: "820 × 1180",
+		width: 820,
+		height: 1180
+	},
+	"ipad-pro": {
+		label: "iPad Pro",
+		category: "Tablet",
+		detail: "1024 × 1366",
+		width: 1024,
+		height: 1366
+	},
+	"surface-pro-7": {
+		label: "Surface Pro 7",
+		category: "Tablet",
+		detail: "912 × 1368",
+		width: 912,
+		height: 1368
+	},
+	"surface-duo": {
+		label: "Surface Duo",
+		category: "Phone",
+		detail: "540 × 720",
+		width: 540,
+		height: 720
+	},
+	"galaxy-z-fold-5": {
+		label: "Galaxy Z Fold 5",
+		category: "Phone",
+		detail: "344 × 882",
+		width: 344,
+		height: 882
+	},
+	"asus-zenbook-fold": {
+		label: "Asus Zenbook Fold",
+		category: "Tablet",
+		detail: "853 × 1280",
+		width: 853,
+		height: 1280
+	},
+	"samsung-galaxy-a51-71": {
+		label: "Samsung Galaxy A51/71",
+		category: "Phone",
+		detail: "412 × 914",
+		width: 412,
+		height: 914
+	},
+	"nest-hub": {
+		label: "Nest Hub",
+		category: "Tablet",
+		detail: "1024 × 600",
+		width: 1024,
+		height: 600
+	},
+	"nest-hub-max": {
+		label: "Nest Hub Max",
+		category: "Tablet",
+		detail: "1280 × 800",
+		width: 1280,
+		height: 800
+	}
+};
+const PREVIEW_VIEWPORT_PRESETS = PREVIEW_VIEWPORT_PRESET_IDS.map((id) => ({
+	id,
+	...PREVIEW_VIEWPORT_PRESET_DEFINITIONS[id]
+}));
+function resolvePreviewViewport(input) {
+	if (input.mode === "fill") return { _tag: "fill" };
+	if (input.mode === "preset" && input.preset !== void 0) {
+		const preset = PREVIEW_VIEWPORT_PRESETS.find((candidate) => candidate.id === input.preset);
+		if (!preset) throw new Error(`Unknown preview viewport preset: ${input.preset}`);
+		const landscape = input.orientation === "landscape";
+		const portrait = input.orientation === "portrait";
+		const nativePortrait = preset.height >= preset.width;
+		const shouldSwap = landscape && nativePortrait || portrait && !nativePortrait;
+		return {
+			_tag: "preset",
+			width: shouldSwap ? preset.height : preset.width,
+			height: shouldSwap ? preset.width : preset.height,
+			presetId: preset.id
+		};
+	}
+	if (input.width === void 0 || input.height === void 0) throw new Error("Custom preview viewport requires width and height");
+	return {
+		_tag: "freeform",
+		width: input.width,
+		height: input.height
+	};
+}
+function previewViewportLabel(viewport) {
+	return viewport._tag === "fill" ? "Fill panel" : `${viewport.width} × ${viewport.height}`;
+}
+function previewViewportPresetOrientation(viewport) {
+	if (viewport._tag === "fill" || viewport.width === viewport.height) return null;
+	return viewport.width > viewport.height ? "landscape" : "portrait";
+}
+//#endregion
+export { PREVIEW_VIEWPORT_PRESETS, previewViewportLabel, previewViewportPresetOrientation, resolvePreviewViewport };

package/dist/shared/projectFavicon.d.ts

@@ -0,0 +1,5 @@
+//#region upstream-t3code/packages/shared/src/projectFavicon.d.ts
+declare const PROJECT_FAVICON_FALLBACK_MARKER = "project-favicon-missing";
+declare function isProjectFaviconFallbackUrl(url: string | null | undefined): boolean;
+//#endregion
+export { PROJECT_FAVICON_FALLBACK_MARKER, isProjectFaviconFallbackUrl };

package/dist/shared/projectFavicon.js

@@ -0,0 +1,13 @@
+//#region upstream-t3code/packages/shared/src/projectFavicon.ts
+const PROJECT_FAVICON_FALLBACK_MARKER = "project-favicon-missing";
+function isProjectFaviconFallbackUrl(url) {
+	if (!url) return false;
+	try {
+		const pathname = new URL(url, "https://t3.invalid").pathname;
+		return pathname.slice(pathname.lastIndexOf("/") + 1) === PROJECT_FAVICON_FALLBACK_MARKER;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { PROJECT_FAVICON_FALLBACK_MARKER, isProjectFaviconFallbackUrl };

package/dist/shared/projectScripts.d.ts

@@ -0,0 +1,19 @@
+import { Ev as ProjectScript } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/projectScripts.d.ts
+interface ProjectScriptRuntimeEnvInput {
+  project: {
+    cwd: string;
+  };
+  worktreePath?: string | null;
+  extraEnv?: Record<string, string>;
+}
+declare function projectScriptCwd(input: {
+  project: {
+    cwd: string;
+  };
+  worktreePath?: string | null;
+}): string;
+declare function projectScriptRuntimeEnv(input: ProjectScriptRuntimeEnvInput): Record<string, string>;
+declare function setupProjectScript(scripts: readonly ProjectScript[]): ProjectScript | null;
+//#endregion
+export { projectScriptCwd, projectScriptRuntimeEnv, setupProjectScript };

package/dist/shared/projectScripts.js

@@ -0,0 +1,18 @@
+//#region upstream-t3code/packages/shared/src/projectScripts.ts
+function projectScriptCwd(input) {
+	return input.worktreePath ?? input.project.cwd;
+}
+function projectScriptRuntimeEnv(input) {
+	const env = { T3CODE_PROJECT_ROOT: input.project.cwd };
+	if (input.worktreePath) env.T3CODE_WORKTREE_PATH = input.worktreePath;
+	if (input.extraEnv) return {
+		...env,
+		...input.extraEnv
+	};
+	return env;
+}
+function setupProjectScript(scripts) {
+	return scripts.find((script) => script.runOnWorktreeCreate) ?? null;
+}
+//#endregion
+export { projectScriptCwd, projectScriptRuntimeEnv, setupProjectScript };

package/dist/shared/qrCode.d.ts

@@ -0,0 +1,87 @@
+//#region upstream-t3code/packages/shared/src/qrCode.d.ts
+type bit = number;
+type byte = number;
+type int = number;
+declare class QrCode {
+  static Ecc: typeof QrCodeEcc;
+  static encodeText(text: string, ecl: QrCodeEcc): QrCode;
+  static encodeBinary(data: Readonly<Array<byte>>, ecl: QrCodeEcc): QrCode;
+  static encodeSegments(segs: Readonly<Array<QrSegment>>, ecl: QrCodeEcc, minVersion?: int, maxVersion?: int, mask?: int, boostEcl?: boolean): QrCode;
+  readonly version: int;
+  readonly errorCorrectionLevel: QrCodeEcc;
+  readonly size: int;
+  readonly mask: int;
+  private readonly modules;
+  private readonly isFunction;
+  constructor(version: int, errorCorrectionLevel: QrCodeEcc, dataCodewords: Readonly<Array<byte>>, msk: int);
+  getModule(x: int, y: int): boolean;
+  private drawFunctionPatterns;
+  private drawFormatBits;
+  private drawVersion;
+  private drawFinderPattern;
+  private drawAlignmentPattern;
+  private setFunctionModule;
+  private addEccAndInterleave;
+  private drawCodewords;
+  private applyMask;
+  private getPenaltyScore;
+  private getAlignmentPatternPositions;
+  private static getNumRawDataModules;
+  private static getNumDataCodewords;
+  private static reedSolomonComputeDivisor;
+  private static reedSolomonComputeRemainder;
+  private static reedSolomonMultiply;
+  private finderPenaltyCountPatterns;
+  private finderPenaltyTerminateAndCount;
+  private finderPenaltyAddHistory;
+  static readonly MIN_VERSION: int;
+  static readonly MAX_VERSION: int;
+  private static readonly PENALTY_N1;
+  private static readonly PENALTY_N2;
+  private static readonly PENALTY_N3;
+  private static readonly PENALTY_N4;
+  private static readonly ECC_CODEWORDS_PER_BLOCK;
+  private static readonly NUM_ERROR_CORRECTION_BLOCKS;
+}
+declare class QrSegment {
+  static Mode: typeof QrSegmentMode;
+  static makeBytes(data: Readonly<Array<byte>>): QrSegment;
+  static makeNumeric(digits: string): QrSegment;
+  static makeAlphanumeric(text: string): QrSegment;
+  static makeSegments(text: string): Array<QrSegment>;
+  static makeEci(assignVal: int): QrSegment;
+  static isNumeric(text: string): boolean;
+  static isAlphanumeric(text: string): boolean;
+  readonly mode: QrSegmentMode;
+  readonly numChars: int;
+  private readonly bitData;
+  constructor(mode: QrSegmentMode, numChars: int, bitData: Array<bit>);
+  getData(): Array<bit>;
+  static getTotalBits(segs: Readonly<Array<QrSegment>>, version: int): number;
+  private static toUtf8ByteArray;
+  private static readonly NUMERIC_REGEX;
+  private static readonly ALPHANUMERIC_REGEX;
+  private static readonly ALPHANUMERIC_CHARSET;
+}
+declare class QrCodeEcc {
+  static readonly LOW: QrCodeEcc;
+  static readonly MEDIUM: QrCodeEcc;
+  static readonly QUARTILE: QrCodeEcc;
+  static readonly HIGH: QrCodeEcc;
+  readonly ordinal: int;
+  readonly formatBits: int;
+  private constructor();
+}
+declare class QrSegmentMode {
+  static readonly NUMERIC: QrSegmentMode;
+  static readonly ALPHANUMERIC: QrSegmentMode;
+  static readonly BYTE: QrSegmentMode;
+  static readonly KANJI: QrSegmentMode;
+  static readonly ECI: QrSegmentMode;
+  readonly modeBits: int;
+  private readonly numBitsCharCount;
+  private constructor();
+  numCharCountBits(ver: int): int;
+}
+//#endregion
+export { QrCode, QrSegment };