The best way to control Claude Code, Codex and more from any computer or phone

main
ts 115 lines 4.07 KB
Raw
1 import { decodeMsg, decodeOptions, mFallback } from "gt-i18n";
2 import type { MFunctionType } from "gt-i18n/types";
3 import * as Schema from "effect/Schema";
4
5 /**
6 * One or more `msg()` sentences shown together, joined by a space. Errors carry it beside
7 * their English `message` so logs and English comparisons keep working.
8 */
9 export type MarkedText = ReadonlyArray<string>;
10 export const MarkedText = Schema.Array(Schema.String);
11
12 function englishSentence(marked: string): string {
13 return typeof decodeOptions(marked)?.$_source === "string" ? decodeMsg(marked) : marked;
14 }
15
16 export function markedTextEnglish(text: MarkedText): string {
17 return text.map(englishSentence).join(" ");
18 }
19
20 export function resolveMarkedText(text: MarkedText, resolve: MFunctionType = mFallback): string {
21 return text.map((sentence) => resolve(sentence)).join(" ");
22 }
23
24 /** `detail` in English plus the marked text, for errors whose `message` reads `detail`. */
25 export function translatableDetail(...text: MarkedText): {
26 readonly detail: string;
27 readonly i18nMessage: MarkedText;
28 } {
29 return { detail: markedTextEnglish(text), i18nMessage: text };
30 }
31
32 /** `message` in English plus the marked text. */
33 export function translatableMessage(...text: MarkedText): {
34 readonly message: string;
35 readonly i18nMessage: MarkedText;
36 } {
37 return { message: markedTextEnglish(text), i18nMessage: text };
38 }
39
40 export function errorI18nMessage(error: unknown): MarkedText | undefined {
41 if (typeof error !== "object" || error === null || !("i18nMessage" in error)) return undefined;
42 const text = error.i18nMessage;
43 return Array.isArray(text) && text.every((sentence) => typeof sentence === "string")
44 ? text
45 : undefined;
46 }
47
48 /**
49 * What to show for an error: its marked text in the active language when it has one,
50 * otherwise its non-empty `message`, otherwise null.
51 */
52 export function errorDisplayMessage(
53 error: unknown,
54 resolve: MFunctionType = mFallback,
55 ): string | null {
56 const text = errorI18nMessage(error);
57 if (text !== undefined) return resolveMarkedText(text, resolve);
58 if (typeof error !== "object" || error === null || !("message" in error)) return null;
59 return typeof error.message === "string" && error.message.trim().length > 0
60 ? error.message
61 : null;
62 }
63
64 /**
65 * A thrown `Error`'s text in the active language, its plain `message` (even empty) when it has no
66 * marked text, and null for anything that is not an `Error`.
67 */
68 export function thrownErrorMessage(
69 error: unknown,
70 resolve: MFunctionType = mFallback,
71 ): string | null {
72 if (!(error instanceof Error)) return null;
73 const text = errorI18nMessage(error);
74 return text === undefined ? error.message : resolveMarkedText(text, resolve);
75 }
76
77 /** Carries another error's message, and its marked text when it has one, into `detail`. */
78 export function detailFromError(error: { readonly message: string }): {
79 readonly detail: string;
80 readonly i18nMessage?: MarkedText;
81 } {
82 const text = errorI18nMessage(error);
83 return text === undefined
84 ? { detail: error.message }
85 : { detail: error.message, i18nMessage: text };
86 }
87
88 /** Carries another error's message, and its marked text when it has one, into `message`. */
89 export function messageFromError(error: { readonly message: string }): {
90 readonly message: string;
91 readonly i18nMessage?: MarkedText;
92 } {
93 const text = errorI18nMessage(error);
94 return text === undefined
95 ? { message: error.message }
96 : { message: error.message, i18nMessage: text };
97 }
98
99 /** A plain `Error` whose `message` stays English and that carries its marked text. */
100 export function translatableError(
101 ...text: MarkedText
102 ): Error & { readonly i18nMessage: MarkedText } {
103 return Object.assign(new Error(markedTextEnglish(text)), { i18nMessage: text });
104 }
105
106 /**
107 * Attaches marked text to an error whose class lives in `@t3tools/contracts`, so it cannot
108 * declare the field. Use only when the error's `message` is exactly that text in English.
109 */
110 export function withI18nMessage<E extends Error>(
111 error: E,
112 ...text: MarkedText
113 ): E & { readonly i18nMessage: MarkedText } {
114 return Object.assign(error, { i18nMessage: text });
115 }