@mojojs/core 1.26.18 → 2.0.0

package/lib/context.d.ts

@@ -1,15 +1,16 @@
-import type { App } from './app.js';
-import type { ChildLogger } from './logger.js';
-import type { Plan } from './router/plan.js';
-import type { ServerRequest } from './server/request.js';
-import type { ServerResponse } from './server/response.js';
-import type { BackendInfo, MojoAction, MojoModels, MojoRenderOptions, MojoURLOptions, ScopedNestedHelpers, SessionData, UploadOptions, ValidatorFunction } from './types.js';
-import type { UserAgent } from './user-agent.js';
-import type { WebSocket } from './websocket.js';
+import type { App } from './app.ts';
+import type { ChildLogger } from './logger.ts';
+import type { Plan } from './router/plan.ts';
+import type { ServerRequest } from './server/request.ts';
+import type { ServerResponse } from './server/response.ts';
+import type { BackendInfo, MojoAction, MojoModels, MojoRenderOptions, MojoURLOptions, ScopedNestedHelpers, SessionData, SSEEvent, UploadOptions, ValidatorFunction } from './types.ts';
+import type { UserAgent } from './user-agent.ts';
+import type { WebSocket } from './websocket.ts';
 import type Path from '@mojojs/path';
 import EventEmitter from 'node:events';
-import { Params } from './body/params.js';
-import { SafeString } from './util.js';
+import { PassThrough } from 'node:stream';
+import { Params } from './body/params.ts';
+import { SafeString } from './util.ts';
 type WebSocketHandler = (ws: WebSocket) => void | Promise<void>;
 interface ContextEvents {
     connection: (ws: WebSocket) => void;
@@ -105,6 +106,7 @@ declare class Context extends EventEmitter implements ContextEventEmitter {
     _nestedHelpersCache: Record<string, ScopedNestedHelpers>;
     _params: Params | undefined;
     _session: Record<string, any> | undefined;
+    _sse: PassThrough | undefined;
     _ws: WeakRef<WebSocket> | null;
     constructor(app: App, req: ServerRequest, res: ServerResponse, backend: BackendInfo);
     [EventEmitter.captureRejectionSymbol](error: Error): void;
@@ -126,6 +128,10 @@ declare class Context extends EventEmitter implements ContextEventEmitter {
      * await ctx.contentFor('head', '<link rel="icon" href="/static/favicon.ico">');
      */
     contentFor(name: string, content: string | SafeString | Promise<string | SafeString> | (() => Promise<string | SafeString>)): Promise<void>;
+    /**
+     * Finish Server-Sent Events response. Note that this method is EXPERIMENTAL and might change without warning!
+     */
+    finishSSE(): void;
     /**
      * Data storage persistent only for the next request.
      * @example
@@ -286,6 +292,23 @@ declare class Context extends EventEmitter implements ContextEventEmitter {
      * Established WebSocket connection.
      */
     get ws(): WebSocket | null;
+    /**
+     * Write Server-Sent Event, and wait for it to be written. Calling this method without an event will just send the
+     * response headers and allow for events to be written later. Note that this method is EXPERIMENTAL and might change
+     * without warning!
+     * @example
+     * // Send event with default "message" type
+     * await ctx.writeSSE({text: 'Hello World!'});
+     *
+     * // You can send comments in regular intervals to keep the connection alive
+     * await ctx.writeSSE({comment: 'Keep connection alive!'});
+     *
+     * // Send events with id and type
+     * await ctx.writeSSE({id: 23, type: 'greeting', text: 'Hello World!'});
+     * await ctx.writeSSE({id: 24, type: 'farewell', text: 'Goodbye World!'});
+     * ctx.finishSSE();
+     */
+    writeSSE(event?: SSEEvent): Promise<void>;
     _urlForPath(path: string, isWebSocket: boolean, options: MojoURLOptions): string;
 }
 export { Context };

package/lib/context.js

@@ -1,46 +1,110 @@
 import EventEmitter from 'node:events';
 import querystring from 'node:querystring';
-import { Params } from './body/params.js';
-import { SafeString } from './util.js';
+import { PassThrough } from 'node:stream';
+import { Params } from "./body/params.js";
+import { buildEvent } from "./sse.js";
+import { SafeString } from "./util.js";
 const ABSOLUTE = /^[a-zA-Z][a-zA-Z0-9]*:\/\//;
 /**
  * Context class.
  */
 class Context extends EventEmitter {
+    /**
+     * Application this context belongs to.
+     */
+    app;
+    /**
+     * Backend information for server that received the request.
+     * @example
+     * // Backend name (usually "server", "cgi", or "mock")
+     * const {name} = ctx.backend;
+     *
+     * // Use low level Node.js APIs with "server" backend
+     * const {res} = ctx.backend;
+     * res.writeHead(200);
+     * res.end('Hello World!');
+     */
+    backend;
+    /**
+     * Partial content. Always returns at least an empty string, even for sections that have not been defined with
+     * `ctx.contentFor()`.
+     * @example
+     * // Get content for "head" section
+     * const head = ctx.content.head;
+     */
+    content = new Proxy({}, {
+        get: function (target, name) {
+            return new SafeString(target[name] ?? '');
+        }
+    });
+    /**
+     * Format for HTTP exceptions ("html", "json", or "txt").
+     */
+    exceptionFormat;
+    /**
+     * WebSocket JSON mode.
+     */
+    jsonMode = false;
+    /**
+     * Logger with request id.
+     * @example
+     * // Pass logger with context to model
+     * const log = ctx.log;
+     * ctx.model.users.create({name: 'kraih'}, log);
+     */
+    log;
+    /**
+     * Router dispatch plan.
+     */
+    plan = null;
+    /**
+     * HTTP request information.
+     * @example
+     * // Extract request information
+     * const id      = ctx.req.requestId;
+     * const method  = ctx.req.method;
+     * const baseURL = ctx.req.baseURL;
+     * const url     = ctx.req.url;
+     * const query   = ctx.req.query;
+     * const info    = ctx.req.userinfo;
+     * const agent   = ctx.req.get('User-Agent');
+     * const buffer  = await ctx.req.buffer();
+     * const text    = await ctx.req.text();
+     * const form    = await ctx.req.form();
+     * const value   = await ctx.req.json();
+     * const html    = await ctx.req.html();
+     * const xml     = await ctx.req.xml();
+     */
+    req;
+    /**
+     * HTTP response information.
+     * @example
+     * // Force file download by setting a response header
+     * ctx.res.set('Content-Disposition', 'attachment; filename=foo.png;');
+     *
+     * // Make sure response is cached correctly
+     * ctx.res.set('Cache-Control', 'public, max-age=300');
+     * ctx.res.headers.append('Vary', 'Accept-Encoding');
+     */
+    res;
+    /**
+     * Non-persistent data storage and exchange for the current request.
+     */
+    stash = {};
+    _flash = undefined;
+    _nestedHelpersCache = {};
+    _params = undefined;
+    _session = undefined;
+    _sse = undefined;
+    _ws = null;
     constructor(app, req, res, backend) {
         super({ captureRejections: true });
-        /**
-         * Partial content. Always returns at least an empty string, even for sections that have not been defined with
-         * `ctx.contentFor()`.
-         * @example
-         * // Get content for "head" section
-         * const head = ctx.content.head;
-         */
-        this.content = new Proxy({}, {
-            get: function (target, name) {
-                return new SafeString(target[name] ?? '');
-            }
-        });
-        /**
-         * WebSocket JSON mode.
-         */
-        this.jsonMode = false;
-        /**
-         * Router dispatch plan.
-         */
-        this.plan = null;
-        /**
-         * Non-persistent data storage and exchange for the current request.
-         */
-        this.stash = {};
-        this._flash = undefined;
-        this._nestedHelpersCache = {};
-        this._params = undefined;
-        this._session = undefined;
-        this._ws = null;
         this.app = app;
         this.exceptionFormat = app.exceptionFormat;
         this.req = req;
+        // Mounted applications share the request, and the limit of the outer one
+        if (req.maxMessageSize === undefined)
+            req.maxMessageSize = app.maxRequestSize;
         this.res = res;
         this.res.bindContext(this);
         this.backend = backend;
@@ -80,6 +144,12 @@ class Context extends EventEmitter {
     async contentFor(name, content) {
         this.content[name] += await (content instanceof Function ? content() : content);
     }
+    /**
+     * Finish Server-Sent Events response. Note that this method is EXPERIMENTAL and might change without warning!
+     */
+    finishSSE() {
+        this._sse?.end();
+    }
     /**
      * Data storage persistent only for the next request.
      * @example
@@ -361,6 +431,42 @@ class Context extends EventEmitter {
     get ws() {
         return this._ws?.deref() ?? null;
     }
+    /**
+     * Write Server-Sent Event, and wait for it to be written. Calling this method without an event will just send the
+     * response headers and allow for events to be written later. Note that this method is EXPERIMENTAL and might change
+     * without warning!
+     * @example
+     * // Send event with default "message" type
+     * await ctx.writeSSE({text: 'Hello World!'});
+     *
+     * // You can send comments in regular intervals to keep the connection alive
+     * await ctx.writeSSE({comment: 'Keep connection alive!'});
+     *
+     * // Send events with id and type
+     * await ctx.writeSSE({id: 23, type: 'greeting', text: 'Hello World!'});
+     * await ctx.writeSSE({id: 24, type: 'farewell', text: 'Goodbye World!'});
+     * ctx.finishSSE();
+     */
+    async writeSSE(event) {
+        let stream = this._sse;
+        if (stream === undefined) {
+            stream = this._sse = new PassThrough();
+            this.on('finish', () => stream?.destroy());
+            await this.res.type('text/event-stream').send(stream);
+        }
+        if (event === undefined || stream.destroyed === true)
+            return;
+        if (stream.write(buildEvent(event)) === true)
+            return;
+        // Wait for drain, or the connection to be closed
+        await new Promise(resolve => {
+            const done = () => {
+                stream.off('drain', done).off('close', done);
+                resolve();
+            };
+            stream.on('drain', done).on('close', done);
+        });
+    }
     _urlForPath(path, isWebSocket, options) {
         path = this.req.basePath + (path === '' ? '/' : path);
         let queryFragment = '';
@@ -376,4 +482,3 @@ class Context extends EventEmitter {
     }
 }
 export { Context };
-//# sourceMappingURL=context.js.map

package/lib/core.d.ts

@@ -3,21 +3,22 @@
  * Copyright (C) 2021-2024 Sebastian Riedel
  * MIT Licensed
  */
-import type { AppOptions } from './types.js';
-import { App } from './app.js';
+import type { AppOptions } from './types.ts';
+import { App } from './app.ts';
 export declare const version: any;
 /**
  * Create a new mojo.js application.
  */
 export default function mojo(options?: AppOptions): App;
-export { default as jsonConfigPlugin } from './plugins/json-config.js';
-export { default as yamlConfigPlugin } from './plugins/yaml-config.js';
-export { default as mountPlugin } from './plugins/mount.js';
-export { CGI } from './cgi.js';
-export { Logger } from './logger.js';
-export { Server } from './server.js';
-export { Session } from './session.js';
-export { TestUserAgent } from './user-agent/test.js';
-export { UserAgent } from './user-agent.js';
-export * as util from './util.js';
-export { JSONValue, MojoAction, MojoApp, MojoContext, MojoModels, MojoRenderOptions, MojoRoute, MojoTags, MojoURLOptions } from './types.js';
+export { default as jsonConfigPlugin } from './plugins/json-config.ts';
+export { default as yamlConfigPlugin } from './plugins/yaml-config.ts';
+export { default as mountPlugin } from './plugins/mount.ts';
+export { CGI } from './cgi.ts';
+export { Logger } from './logger.ts';
+export { Server } from './server.ts';
+export { Session } from './session.ts';
+export { buildEvent, parseEvent } from './sse.ts';
+export { TestUserAgent } from './user-agent/test.ts';
+export { UserAgent } from './user-agent.ts';
+export * as util from './util.ts';
+export type { JSONValue, MojoAction, MojoApp, MojoContext, MojoModels, MojoRenderOptions, MojoRoute, MojoTags, MojoURLOptions, SSEEvent } from './types.ts';

package/lib/core.js

@@ -1,4 +1,4 @@
-import { App } from './app.js';
+import { App } from "./app.js";
 import Path from '@mojojs/path';
 export const version = JSON.parse(Path.currentFile().dirname().sibling('package.json').readFileSync().toString()).version;
 /**
@@ -22,14 +22,14 @@ export default function mojo(options) {
     return app;
 }
 // "Professor: These old Doomsday devices are dangerously unstable. I'll rest easier not knowing where they are."
-export { default as jsonConfigPlugin } from './plugins/json-config.js';
-export { default as yamlConfigPlugin } from './plugins/yaml-config.js';
-export { default as mountPlugin } from './plugins/mount.js';
-export { CGI } from './cgi.js';
-export { Logger } from './logger.js';
-export { Server } from './server.js';
-export { Session } from './session.js';
-export { TestUserAgent } from './user-agent/test.js';
-export { UserAgent } from './user-agent.js';
-export * as util from './util.js';
-//# sourceMappingURL=core.js.map
+export { default as jsonConfigPlugin } from "./plugins/json-config.js";
+export { default as yamlConfigPlugin } from "./plugins/yaml-config.js";
+export { default as mountPlugin } from "./plugins/mount.js";
+export { CGI } from "./cgi.js";
+export { Logger } from "./logger.js";
+export { Server } from "./server.js";
+export { Session } from "./session.js";
+export { buildEvent, parseEvent } from "./sse.js";
+export { TestUserAgent } from "./user-agent/test.js";
+export { UserAgent } from "./user-agent.js";
+export * as util from "./util.js";

package/lib/headers.js

@@ -13,6 +13,8 @@ const HOP_BY_HOP = [
  * HTTP header class.
  */
 export class Headers {
+    _headers;
+    _init;
     constructor(init = []) {
         this._init = init;
     }
@@ -70,7 +72,6 @@ export class Headers {
      * const {link, title} = headers.getLinks().next;
      */
     getLinks() {
-        var _a;
         const data = {};
         let value = this.get('Link') ?? '';
         while (value.length > 0) {
@@ -81,7 +82,7 @@ export class Headers {
             const { params, remainder } = headerParams(linkMatch[2]);
             value = remainder;
             if (params.rel !== undefined)
-                data[_a = params.rel] ?? (data[_a] = { ...params, link });
+                data[params.rel] ??= { ...params, link };
         }
         return data;
     }
@@ -149,7 +150,8 @@ export class Headers {
     }
     _getHeaders() {
         if (this._headers === undefined) {
-            const headers = (this._headers = {});
+            // No prototype, so names like "constructor" are just regular headers
+            const headers = (this._headers = Object.create(null));
             const init = this._init;
             for (let i = 0; i < init.length; i += 2) {
                 const name = init[i];
@@ -166,4 +168,3 @@ export class Headers {
         return this._headers;
     }
 }
-//# sourceMappingURL=headers.js.map

package/lib/hooks.d.ts

@@ -1,4 +1,4 @@
-import type { MojoApp } from './types.js';
+import type { MojoApp } from './types.ts';
 import { AsyncHooks } from '@mojojs/util';
 /**
  * Hook class.

package/lib/hooks.js

@@ -3,10 +3,7 @@ import { AsyncHooks } from '@mojojs/util';
  * Hook class.
  */
 export class Hooks extends AsyncHooks {
-    constructor() {
-        super(...arguments);
-        this._lifecycleHookScore = 0;
-    }
+    _lifecycleHookScore = 0;
     /**
      * Run `command:before` hook with dependencies. Note that this method is EXPERIMENTAL and might change without
      * warning!
@@ -49,4 +46,3 @@ export class Hooks extends AsyncHooks {
             await this.runHook('app:stop', app);
     }
 }
-//# sourceMappingURL=hooks.js.map

package/lib/logger.d.ts

@@ -8,7 +8,7 @@ interface LogEvent extends LogContext {
     time: string;
     msg: string;
 }
-type LogFormatter = (data: LogEvent) => string;
+type LogFormatter = (data: LogEvent, destination: NodeJS.WritableStream) => string;
 /**
  * A simple logger class.
  */
@@ -45,7 +45,7 @@ export declare class Logger {
     /**
      * Log formatter with color highlighting.
      */
-    static colorFormatter(data: LogEvent): string;
+    static colorFormatter(data: LogEvent, destination?: NodeJS.WritableStream): string;
     /**
      * Log `debug` message.
      */

package/lib/logger.js

@@ -1,5 +1,5 @@
 import assert from 'node:assert';
-import chalk from 'chalk';
+import { styleText } from 'node:util';
 const LEVEL = {
     fatal: 2,
     error: 3,
@@ -12,13 +12,22 @@ const LEVEL = {
  * A simple logger class.
  */
 export class Logger {
+    /**
+     * Log destination stream.
+     */
+    destination;
+    /**
+     * Log formatter.
+     */
+    formatter;
+    /**
+     * The last few logged messages.
+     */
+    history = [];
+    _capture = undefined;
+    _historySize;
+    _level = 7;
     constructor(options = {}) {
-        /**
-         * The last few logged messages.
-         */
-        this.history = [];
-        this._capture = undefined;
-        this._level = 7;
         this.destination = options.destination ?? process.stderr;
         this.formatter = options.formatter ?? Logger.colorFormatter;
         this.level = process.env.MOJO_LOG_LEVEL ?? options.level ?? 'trace';
@@ -47,13 +56,14 @@ export class Logger {
     /**
      * Log formatter with color highlighting.
      */
-    static colorFormatter(data) {
+    static colorFormatter(data, destination = process.stderr) {
         const formatted = Logger.stringFormatter(data);
-        if (data.level === 'error' || data.level === 'fatal')
-            return chalk.red(formatted);
-        if (data.level === 'warn')
-            return chalk.yellow(formatted);
-        return formatted;
+        const { level } = data;
+        const color = level === 'error' || level === 'fatal' ? 'red' : level === 'warn' ? 'yellow' : null;
+        if (color === null)
+            return formatted;
+        // Keep the trailing newline outside of the color codes, and only use colors if the destination supports them
+        return styleText(color, formatted.slice(0, -1), { stream: destination }) + '\n';
     }
     /**
      * Log `debug` message.
@@ -139,7 +149,7 @@ export class Logger {
             if (historySize > maxHistorySize)
                 history.splice(0, historySize - maxHistorySize);
         }
-        const formatted = this.formatter(data);
+        const formatted = this.formatter(data, this.destination);
         if (this._capture === undefined) {
             this.destination.write(formatted);
         }
@@ -152,9 +162,10 @@ export class Logger {
  * Captured log message class.
  */
 class CapturedLogs extends Array {
+    _cb;
+    _stopped = false;
     constructor(cb) {
         super();
-        this._stopped = false;
         this._cb = cb;
     }
     /**
@@ -177,6 +188,8 @@ class CapturedLogs extends Array {
  * Child logger class.
  */
 export class ChildLogger {
+    parent;
+    context;
     constructor(parent, context) {
         this.parent = parent;
         this.context = context;
@@ -218,4 +231,3 @@ export class ChildLogger {
         this.parent.warn(msg, this.context);
     }
 }
-//# sourceMappingURL=logger.js.map

package/lib/mime.js

@@ -3,18 +3,16 @@ import mime from 'mime-types';
  * MIME class.
  */
 export class Mime {
-    constructor() {
-        /**
-         * Custom MIME types.
-         */
-        this.custom = {
-            html: 'text/html; charset=utf-8',
-            json: 'application/json; charset=utf-8',
-            txt: 'text/plain; charset=utf-8',
-            yaml: 'text/yaml; charset=utf-8'
-        };
-        this._reverseCustom = undefined;
-    }
+    /**
+     * Custom MIME types.
+     */
+    custom = {
+        html: 'text/html; charset=utf-8',
+        json: 'application/json; charset=utf-8',
+        txt: 'text/plain; charset=utf-8',
+        yaml: 'text/yaml; charset=utf-8'
+    };
+    _reverseCustom = undefined;
     /**
      * Detect file extensions from `Accept` header value.
      */
@@ -50,4 +48,3 @@ export class Mime {
         return this.custom[ext] ?? mime.types[ext] ?? null;
     }
 }
-//# sourceMappingURL=mime.js.map

package/lib/plugins/default-conditions.d.ts

@@ -1,4 +1,4 @@
-import type { App } from '../app.js';
+import type { App } from '../app.ts';
 /**
  * Default condition plugin.
  */

package/lib/plugins/default-conditions.js

@@ -19,4 +19,3 @@ async function headerCondition(ctx, requirement) {
 async function hostCondition(ctx, requirement) {
     return headerCondition(ctx, { Host: requirement });
 }
-//# sourceMappingURL=default-conditions.js.map

package/lib/plugins/default-helpers.d.ts

@@ -1,4 +1,4 @@
-import type { MojoApp } from '../types.js';
+import type { MojoApp } from '../types.ts';
 /**
  * Default helper plugin.
  */

package/lib/plugins/default-helpers.js

@@ -1,6 +1,6 @@
 import { inspect } from 'node:util';
-import { Logger } from '../logger.js';
-import { exceptionContext, SafeString } from '../util.js';
+import { Logger } from "../logger.js";
+import { exceptionContext, HTTPError, httpStatusMessages, SafeString } from "../util.js";
 import DOM from '@mojojs/dom';
 /**
  * Default helper plugin.
@@ -140,12 +140,13 @@ async function hiddenFieldTag(ctx, name, value, attrs = {}) {
 async function htmlException(ctx, error) {
     ctx.stash.exception = error;
     const mode = ctx.app.mode;
-    if (await ctx.render({ view: `exception.${mode}`, maybe: true, status: 500 }))
+    const status = errorStatus(error);
+    if (await ctx.render({ view: `exception.${mode}`, maybe: true, status }))
         return true;
-    if (await ctx.render({ view: 'exception', maybe: true, status: 500 }))
+    if (await ctx.render({ view: 'exception', maybe: true, status }))
         return true;
     const view = mode === 'development' ? 'mojo/debug' : 'mojo/exception';
-    return await ctx.render({ view, status: 500, stringFormatter: Logger.stringFormatter, exceptionContext });
+    return await ctx.render({ view, status, stringFormatter: Logger.stringFormatter, exceptionContext });
 }
 async function htmlNotFound(ctx) {
     ctx.stash.exception = null;
@@ -159,7 +160,15 @@ async function htmlNotFound(ctx) {
 }
 async function httpException(ctx, error) {
     error = ensureError(error);
-    ctx.log.error(error.stack);
+    // Client errors are not worth a stack trace
+    const status = errorStatus(error);
+    if (status < 500)
+        ctx.log.debug(error.message);
+    else
+        ctx.log.error(error.stack);
+    // Do not wait for the rest of a request body that is too large
+    if (status === 413)
+        ctx.res.set('Connection', 'close');
     const exceptionFormat = ctx.exceptionFormat;
     if (exceptionFormat === 'txt')
         return ctx.txtException(error);
@@ -195,6 +204,7 @@ async function include(ctx, options, stash) {
     return str === null ? null : new SafeString(str);
 }
 async function jsonException(ctx, error) {
+    const status = errorStatus(error);
     if (ctx.app.mode === 'development') {
         return await ctx.render({
             json: {
@@ -205,10 +215,10 @@ async function jsonException(ctx, error) {
                 }
             },
             pretty: true,
-            status: 500
+            status
         });
     }
-    return await ctx.render({ json: { error: { message: 'Internal Server Error' } }, pretty: true, status: 500 });
+    return await ctx.render({ json: { error: { message: httpStatusMessages[status] } }, pretty: true, status });
 }
 async function jsonNotFound(ctx) {
     return await ctx.render({ json: { error: { message: 'Not Found' } }, pretty: true, status: 404 });
@@ -276,10 +286,11 @@ async function textAreaTag(ctx, name, attrs = {}, content) {
     return ctx.tag('textarea', { ...attrs, name }, content);
 }
 async function txtException(ctx, error) {
+    const status = errorStatus(error);
     if (ctx.app.mode === 'development') {
-        return await ctx.render({ text: error.stack, status: 500 });
+        return await ctx.render({ text: error.stack, status });
     }
-    return await ctx.render({ text: 'Internal Server Error', status: 500 });
+    return await ctx.render({ text: httpStatusMessages[status], status });
 }
 async function txtNotFound(ctx) {
     return await ctx.render({ text: 'Not Found', status: 404 });
@@ -299,4 +310,10 @@ function urlTarget(target) {
 function ensureError(error) {
     return error instanceof Error ? error : new Error(error);
 }
-//# sourceMappingURL=default-helpers.js.map
+// Only our own errors, a "status" property from other libraries could hide real server errors
+function errorStatus(error) {
+    if (!(error instanceof HTTPError))
+        return 500;
+    const { status } = error;
+    return Number.isInteger(status) && status >= 400 && status <= 599 ? status : 500;
+}

package/lib/plugins/json-config.d.ts

@@ -1,4 +1,4 @@
-import type { ConfigOptions, MojoApp } from '../types.js';
+import type { ConfigOptions, MojoApp } from '../types.ts';
 /**
  * JSON config plugin.
  */