@loutrejs/loutre 0.1.0 → 0.3.0

package/dist/presentation.d.ts

@@ -0,0 +1,33 @@
+import { LOUTRE_VERSION } from './generated/version.js';
+export interface StartupPresentationInfo {
+    readonly version: string;
+}
+export interface StartupStatusInfo {
+    readonly server: string;
+    readonly runtime: string;
+    readonly environment: string;
+    readonly startupDurationMs: number;
+}
+export interface StartupPresentationSession {
+    ready(info: StartupStatusInfo): void;
+}
+export interface StartupPresentationStartOptions {
+    readonly terminal: PresentationRenderOptions;
+    readonly write: (value: string) => void;
+}
+export { LOUTRE_VERSION };
+export interface PresentationRenderOptions {
+    readonly isTTY: boolean;
+    readonly color: boolean;
+    readonly columns?: number;
+}
+export interface PresentationTerminalOutput {
+    readonly isTTY?: boolean;
+    readonly columns?: number;
+    readonly getColorDepth: (environment?: Readonly<Record<string, string | undefined>>) => number;
+}
+export declare function detectPresentationTerminal(output: PresentationTerminalOutput, environment: Readonly<Record<string, string | undefined>>): PresentationRenderOptions;
+export declare function startStartupPresentation(info: StartupPresentationInfo, options: StartupPresentationStartOptions): StartupPresentationSession;
+export declare function renderLoutreBrand(options: PresentationRenderOptions): string;
+export declare function renderStartupPrelude(info: StartupPresentationInfo, options: PresentationRenderOptions): string;
+export declare function renderStartupStatus(info: StartupStatusInfo, options: PresentationRenderOptions): string;

package/dist/presentation.js

@@ -0,0 +1,233 @@
+import { LOUTRE_VERSION } from './generated/version.js';
+export { LOUTRE_VERSION };
+export function detectPresentationTerminal(output, environment) {
+    const isTTY = output.isTTY === true;
+    const colorDisabled = environment.NO_COLOR !== undefined ||
+        environment.NODE_DISABLE_COLORS !== undefined;
+    const columns = output.columns;
+    return {
+        isTTY,
+        color: isTTY && !colorDisabled && output.getColorDepth(environment) >= 24,
+        ...(columns !== undefined && columns > 0 ? { columns } : {}),
+    };
+}
+export function startStartupPresentation(info, options) {
+    options.write(renderStartupPrelude(info, options.terminal));
+    return {
+        ready(status) {
+            options.write(renderStartupStatus(status, options.terminal));
+        },
+    };
+}
+const colors = {
+    otterLight: [244, 211, 164],
+    otterSand: [224, 179, 119],
+    otterCaramel: [198, 139, 75],
+    otterBrown: [167, 105, 58],
+    otterDeep: [112, 66, 45],
+    lavender: [192, 132, 252],
+    lavenderSoft: [196, 181, 253],
+    label: [103, 232, 249],
+    value: [74, 222, 128],
+    text: [148, 163, 184],
+    frame: [71, 85, 105],
+};
+const logoGlyphs = [
+    ['██╗     ', '██║     ', '██║     ', '██║     ', '███████╗', '╚══════╝'],
+    [
+        ' ██████╗ ',
+        '██╔═══██╗',
+        '██║   ██║',
+        '██║   ██║',
+        '╚██████╔╝',
+        ' ╚═════╝ ',
+    ],
+    [
+        '██╗   ██╗',
+        '██║   ██║',
+        '██║   ██║',
+        '██║   ██║',
+        '╚██████╔╝',
+        ' ╚═════╝ ',
+    ],
+    [
+        '████████╗',
+        '╚══██╔══╝',
+        '   ██║   ',
+        '   ██║   ',
+        '   ██║   ',
+        '   ╚═╝   ',
+    ],
+    ['██████╗ ', '██╔══██╗', '██████╔╝', '██╔══██╗', '██║  ██║', '╚═╝  ╚═╝'],
+    ['███████╗', '██╔════╝', '█████╗  ', '██╔══╝  ', '███████╗', '╚══════╝'],
+];
+const logoColors = [
+    colors.otterLight,
+    colors.otterSand,
+    colors.otterCaramel,
+    colors.otterBrown,
+    colors.otterDeep,
+    colors.otterCaramel,
+];
+const minimumContentWidth = 68;
+const metadataIndent = '        ';
+const mascot = 'ʕ•ᴥ•ʔ';
+export function renderLoutreBrand(options) {
+    if (!options.isTTY)
+        return 'Loutre';
+    if (options.columns !== undefined && options.columns < logoWidth()) {
+        return `${mascot} Loutre`;
+    }
+    const logo = renderLogo(options.color);
+    const brand = options.color
+        ? `${paint(colors.lavender, mascot)} ${paint(colors.lavenderSoft, 'Loutre')}`
+        : `${mascot} Loutre`;
+    return [...logo.styled, '', brand].join('\n');
+}
+export function renderStartupPrelude(info, options) {
+    if (!options.isTTY)
+        return renderCompactPrelude(info);
+    const layout = createStartupLayout(info);
+    if (options.columns !== undefined && options.columns < layout.frameWidth) {
+        return renderCompactPrelude(info);
+    }
+    return renderRichPrelude(info, layout.contentWidth, options.color);
+}
+export function renderStartupStatus(info, options) {
+    if (!options.isTTY)
+        return renderCompactStatus(info);
+    const layout = createStartupLayout(info);
+    if (options.columns !== undefined && options.columns < layout.frameWidth) {
+        return renderCompactStatus(info);
+    }
+    return renderRichStatus(info, layout.contentWidth, options.color);
+}
+function renderCompactPrelude(info) {
+    return `Loutre ${info.version}`;
+}
+function renderCompactStatus(info) {
+    return [
+        `Server: ${info.server}`,
+        `Runtime: ${info.runtime}`,
+        `Environment: ${info.environment}`,
+        `Ready in ${formatDuration(info.startupDurationMs)}`,
+    ].join('\n');
+}
+function renderRichPrelude(info, contentWidth, color) {
+    const layout = createFrameLayout(contentWidth, color);
+    const logo = renderLogo(color);
+    const brand = `${mascot}  version ${info.version}`;
+    const styledBrand = `${paintWhen(color, colors.lavender, mascot)}  ${paintWhen(color, colors.lavenderSoft, `version ${info.version}`)}`;
+    return [
+        layout.topBorder,
+        layout.row(''),
+        ...logo.plain.map((line, index) => layout.centered(line, logo.styled[index])),
+        layout.row(''),
+        layout.centered(brand, styledBrand),
+        layout.row(''),
+    ].join('\n');
+}
+function renderRichStatus(info, contentWidth, color) {
+    const layout = createFrameLayout(contentWidth, color);
+    const labels = ['Server', 'Runtime', 'Environment'];
+    const labelWidth = Math.max(...labels.map(displayWidth));
+    const metadata = [
+        ['Server', info.server],
+        ['Runtime', info.runtime],
+        ['Environment', info.environment],
+    ];
+    return [
+        ...metadata.map(([label, value]) => {
+            const gap = ' '.repeat(labelWidth - displayWidth(label) + 3);
+            const plain = `${metadataIndent}${label}${gap}${value}`;
+            const styled = `${metadataIndent}${paintWhen(color, colors.label, label)}${gap}${paintWhen(color, colors.value, value)}`;
+            return layout.row(plain, styled);
+        }),
+        layout.row(''),
+        layout.bottomBorder,
+        '',
+        `  ${paintWhen(color, colors.value, '✓ Ready')} ${paintWhen(color, colors.text, `in ${formatDuration(info.startupDurationMs)}`)}`,
+    ].join('\n');
+}
+function createStartupLayout(info) {
+    const labelWidth = displayWidth('Environment');
+    const metadata = ('server' in info ? [info.server, info.runtime, info.environment] : []).map((value) => displayWidth(metadataIndent) + labelWidth + 3 + displayWidth(value));
+    const contentWidth = Math.max(minimumContentWidth, logoWidth(), 'version' in info
+        ? displayWidth(`${mascot}  version ${info.version}`)
+        : minimumContentWidth, ...metadata);
+    return { contentWidth, frameWidth: contentWidth + 4 };
+}
+function createFrameLayout(contentWidth, color) {
+    const frame = (value) => paintWhen(color, colors.frame, value);
+    const row = (plain, styled = plain) => `${frame('│')} ${styled}${' '.repeat(contentWidth - displayWidth(plain))} ${frame('│')}`;
+    const centered = (plain, styled = plain) => {
+        const remaining = contentWidth - displayWidth(plain);
+        const left = Math.floor(remaining / 2);
+        return row(`${' '.repeat(left)}${plain}`, `${' '.repeat(left)}${styled}`);
+    };
+    const border = frame('─'.repeat(contentWidth + 2));
+    return {
+        topBorder: `${frame('╭')}${border}${frame('╮')}`,
+        bottomBorder: `${frame('╰')}${border}${frame('╯')}`,
+        row,
+        centered,
+    };
+}
+function renderLogo(color) {
+    const widths = logoGlyphs.map((glyph) => Math.max(...glyph.map(displayWidth)));
+    const plain = [];
+    const styled = [];
+    for (let row = 0; row < logoGlyphs[0].length; row += 1) {
+        const plainParts = [];
+        const styledParts = [];
+        for (let letter = 0; letter < logoGlyphs.length; letter += 1) {
+            const value = logoGlyphs[letter][row];
+            const padded = `${value}${' '.repeat(widths[letter] - displayWidth(value))}`;
+            const rgb = logoColors[letter];
+            plainParts.push(padded);
+            styledParts.push(paintWhen(color, rgb, padded));
+        }
+        plain.push(plainParts.join(' '));
+        styled.push(styledParts.join(' '));
+    }
+    return { plain, styled };
+}
+function logoWidth() {
+    const widths = logoGlyphs.map((glyph) => Math.max(...glyph.map(displayWidth)));
+    return widths.reduce((sum, width) => sum + width, logoGlyphs.length - 1);
+}
+function paintWhen(color, rgb, value) {
+    return color ? paint(rgb, value) : value;
+}
+function paint(rgb, value) {
+    return `\u001B[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m${value}\u001B[0m`;
+}
+function formatDuration(durationMs) {
+    return `${Math.max(0, Math.round(durationMs))} ms`;
+}
+function displayWidth(value) {
+    let width = 0;
+    const ansiControlSequence = new RegExp(`${String.fromCodePoint(0x1b)}\\[[0-?]*[ -/]*[@-~]`, 'g');
+    for (const character of value.replace(ansiControlSequence, '')) {
+        const codePoint = character.codePointAt(0);
+        if (/\p{Mark}/u.test(character))
+            continue;
+        width += isFullWidth(codePoint) ? 2 : 1;
+    }
+    return width;
+}
+function isFullWidth(codePoint) {
+    return (codePoint >= 0x1100 &&
+        (codePoint <= 0x115f ||
+            codePoint === 0x2329 ||
+            codePoint === 0x232a ||
+            (codePoint >= 0x2e80 && codePoint <= 0xa4cf && codePoint !== 0x303f) ||
+            (codePoint >= 0xac00 && codePoint <= 0xd7a3) ||
+            (codePoint >= 0xf900 && codePoint <= 0xfaff) ||
+            (codePoint >= 0xfe10 && codePoint <= 0xfe19) ||
+            (codePoint >= 0xfe30 && codePoint <= 0xfe6f) ||
+            (codePoint >= 0xff00 && codePoint <= 0xff60) ||
+            (codePoint >= 0xffe0 && codePoint <= 0xffe6) ||
+            (codePoint >= 0x1b000 && codePoint <= 0x1ffff) ||
+            (codePoint >= 0x20000 && codePoint <= 0x3fffd)));
+}

package/dist/runtime/capability.js

@@ -11,7 +11,7 @@ export function checkCapabilities(required, runtime) {
 export class MissingCapabilitiesError extends Error {
     check;
     constructor(check) {
-        super(`Runtimeに必要なCapabilityがありません: ${check.missing.join(', ')}`);
+        super(`Runtime is missing required capabilities: ${check.missing.join(', ')}`);
         this.check = check;
         this.name = 'MissingCapabilitiesError';
     }

package/dist/runtime/di.js

@@ -222,7 +222,7 @@ export class Container {
             const cycle = [...lineage.slice(cycleStart), token]
                 .map(tokenName)
                 .join(' -> ');
-            throw new DependencyResolutionError(`LUTRE_DI_CYCLE: 循環依存を検出しました: ${cycle}`);
+            throw new DependencyResolutionError(`LUTRE_DI_CYCLE: Circular dependency detected: ${cycle}`);
         }
         const provider = this.#providers.get(token);
         if (!provider) {
@@ -286,7 +286,7 @@ export class Container {
                     const selected = input[provider.select.key];
                     const implementation = provider.mapping[selected];
                     if (!implementation) {
-                        throw new DependencyResolutionError(`${provider.select.key}=${String(selected)}に対応するconditional Providerがありません`);
+                        throw new DependencyResolutionError(`No conditional Provider matches ${provider.select.key}=${String(selected)}`);
                     }
                     return this.#instantiate(implementation, lineage);
                 }

package/dist/runtime/engine.d.ts

@@ -0,0 +1,3 @@
+export type RuntimeEngine = 'node' | 'bun' | 'deno' | 'cloudflare-workers' | 'aws-lambda' | 'electron' | 'unknown';
+export declare function detectRuntimeEngine(): RuntimeEngine;
+export declare function assertRuntimeEngine(expected: Exclude<RuntimeEngine, 'unknown'>): void;

package/dist/runtime/engine.js

@@ -0,0 +1,38 @@
+const runtimeLabels = {
+    node: 'Node.js',
+    bun: 'Bun',
+    deno: 'Deno',
+    'cloudflare-workers': 'Cloudflare Workers',
+    'aws-lambda': 'AWS Lambda',
+    electron: 'Electron',
+    unknown: 'an unknown runtime',
+};
+export function detectRuntimeEngine() {
+    const globals = globalThis;
+    if (globals.Bun !== undefined ||
+        globals.process?.versions?.bun !== undefined) {
+        return 'bun';
+    }
+    if (globals.Deno !== undefined)
+        return 'deno';
+    if (globals.navigator?.userAgent === 'Cloudflare-Workers' ||
+        globals.WebSocketPair !== undefined) {
+        return 'cloudflare-workers';
+    }
+    if (globals.process?.versions?.electron !== undefined)
+        return 'electron';
+    if (globals.process?.env?.AWS_EXECUTION_ENV?.startsWith('AWS_Lambda_nodejs')) {
+        return 'aws-lambda';
+    }
+    if (globals.process?.release?.name === 'node' ||
+        globals.process?.versions?.node !== undefined) {
+        return 'node';
+    }
+    return 'unknown';
+}
+export function assertRuntimeEngine(expected) {
+    const actual = detectRuntimeEngine();
+    if (actual === expected)
+        return;
+    throw new Error(`LUTRE_RUNTIME_MISMATCH: Expected ${runtimeLabels[expected]}, detected ${runtimeLabels[actual]}.`);
+}

package/dist/runtime/index.d.ts

@@ -2,6 +2,8 @@ export * from './application.js';
 export * from './capability.js';
 export * from './di.js';
 export * from './error.js';
+export * from './engine.js';
 export * from './logger.js';
 export * from './pipeline.js';
 export * from './node-capabilities.js';
+export * from './server-url.js';

package/dist/runtime/index.js

@@ -2,6 +2,8 @@ export * from './application.js';
 export * from './capability.js';
 export * from './di.js';
 export * from './error.js';
+export * from './engine.js';
 export * from './logger.js';
 export * from './pipeline.js';
 export * from './node-capabilities.js';
+export * from './server-url.js';

package/dist/runtime/pipeline.js

@@ -9,7 +9,7 @@ export async function executePipeline(pipeline, hooks) {
     const context = hooks.context;
     const flow = await executeSegment(pipeline, 0, hooks, context, new Set());
     if (flow.kind === 'continue') {
-        throw new Error('Pipelineがresultを生成しませんでした');
+        throw new Error('Pipeline did not produce a result');
     }
     return flow.result;
 }
@@ -48,7 +48,7 @@ async function executeLayer(layer, runtime, continuation, context, availableKeys
     const next = (...arguments_) => {
         calls += 1;
         if (calls > 1) {
-            contractError = new LayerContractError(`LUTRE_LAYER_NEXT_REENTRY: Layer ${layer.name}のnext()は1回だけ実行できます`);
+            contractError = new LayerContractError(`LUTRE_LAYER_NEXT_REENTRY: Layer ${layer.name} can call next() only once`);
             return Promise.reject(contractError);
         }
         applyProvidedContext(layer, context, availableKeys, arguments_);
@@ -90,7 +90,7 @@ async function executeLayer(layer, runtime, continuation, context, availableKeys
         throw runtimeError;
     if (isShortCircuit(runtimeResult)) {
         if (calls > 0) {
-            throw new LayerContractError(`LUTRE_LAYER_SHORT_CIRCUIT_AFTER_NEXT: Layer ${layer.name}はnext()後にshortCircuitできません`);
+            throw new LayerContractError(`LUTRE_LAYER_SHORT_CIRCUIT_AFTER_NEXT: Layer ${layer.name} cannot shortCircuit after next()`);
         }
         return {
             kind: 'complete',
@@ -98,28 +98,28 @@ async function executeLayer(layer, runtime, continuation, context, availableKeys
         };
     }
     if (calls === 0) {
-        throw new LayerContractError(`LUTRE_LAYER_NEXT_SKIPPED: Layer ${layer.name}はnext()を1回実行する必要があります`);
+        throw new LayerContractError(`LUTRE_LAYER_NEXT_SKIPPED: Layer ${layer.name} must call next() exactly once`);
     }
     return continuationFlow;
 }
 function assertRequiredContext(layerName, requiredKeys, availableKeys) {
     for (const required of requiredKeys) {
         if (!availableKeys.has(required)) {
-            throw new LayerContractError(`${layerName}が必要とするContext Key ${contextKeyName(required)}は利用できません`);
+            throw new LayerContractError(`Context Key ${contextKeyName(required)} required by ${layerName} is unavailable`);
         }
     }
 }
 function applyProvidedContext(layer, context, availableKeys, arguments_) {
     if (arguments_.length > 1) {
-        throw new LayerContractError(`${layer.name}のnext()へ渡せるContext objectは1つだけです`);
+        throw new LayerContractError(`Layer ${layer.name} can pass only one Context object to next()`);
     }
     if (layer.provides.length === 0) {
         if (arguments_.length > 0) {
             const provided = arguments_[0];
             const property = firstProperty(provided);
             throw new LayerContractError(property === undefined
-                ? `${layer.name}はContextをprovideすると宣言していません`
-                : `${layer.name}が未宣言のContext property ${property}をprovideしました`);
+                ? `Layer ${layer.name} does not declare any provided Context`
+                : `Layer ${layer.name} provided undeclared Context property ${property}`);
         }
         return;
     }
@@ -127,26 +127,26 @@ function applyProvidedContext(layer, context, availableKeys, arguments_) {
     if (typeof provided !== 'object' ||
         provided === null ||
         Array.isArray(provided)) {
-        throw new LayerContractError(`${layer.name}はprovidesで宣言したContextをnext(object)で渡す必要があります`);
+        throw new LayerContractError(`Layer ${layer.name} must pass its declared Context to next(object)`);
     }
     const additions = provided;
     const declaredNames = new Set(layer.provides.map((key) => key.name));
     for (const property of Object.keys(additions)) {
         if (!declaredNames.has(property)) {
-            throw new LayerContractError(`${layer.name}が未宣言のContext property ${property}をprovideしました`);
+            throw new LayerContractError(`Layer ${layer.name} provided undeclared Context property ${property}`);
         }
     }
     const providedNames = new Set();
     for (const key of layer.provides) {
         if (providedNames.has(key.name)) {
-            throw new LayerContractError(`${layer.name}がContext property ${key.name}を重複して宣言しました`);
+            throw new LayerContractError(`Layer ${layer.name} declared duplicate Context property ${key.name}`);
         }
         providedNames.add(key.name);
         if (!Object.hasOwn(additions, key.name)) {
-            throw new LayerContractError(`${layer.name}が宣言したContext Key ${contextKeyName(key)}をprovideしませんでした`);
+            throw new LayerContractError(`Layer ${layer.name} did not provide declared Context Key ${contextKeyName(key)}`);
         }
         if (Object.hasOwn(context, key.name)) {
-            throw new LayerContractError(`${layer.name}は既存のContext property ${key.name}を上書きできません`);
+            throw new LayerContractError(`Layer ${layer.name} cannot overwrite existing Context property ${key.name}`);
         }
     }
     Object.assign(context, additions);

package/dist/runtime/server-url.d.ts

@@ -0,0 +1 @@
+export declare function serverUrl(hostname: string | undefined, port: number): string;

package/dist/runtime/server-url.js

@@ -0,0 +1,5 @@
+export function serverUrl(hostname, port) {
+    const host = hostname ?? 'localhost';
+    const formattedHost = host.includes(':') ? `[${host}]` : host;
+    return `http://${formattedHost}:${port}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loutrejs/loutre",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "license": "MIT",
   "type": "module",
   "files": [
@@ -24,6 +24,10 @@
       "types": "./dist/application/openapi.d.ts",
       "import": "./dist/application/openapi.js"
     },
+    "./presentation": {
+      "types": "./dist/presentation.d.ts",
+      "import": "./dist/presentation.js"
+    },
     "./graph": {
       "types": "./dist/graph/index.d.ts",
       "import": "./dist/graph/index.js"