@logto/next 1.1.2 → 2.1.0

package/lib/edge/index.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var NodeClient = require('@logto/node/edge');
+var edge = require('iron-session/edge');
+var client = require('../src/client.cjs');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var NodeClient__default = /*#__PURE__*/_interopDefault(NodeClient);
+
+class LogtoClient extends client.default {
+    constructor(config) {
+        super(config, {
+            NodeClient: NodeClient__default.default,
+        });
+        this.handleSignIn = (redirectUri = `${this.config.baseUrl}/api/logto/sign-in-callback`, interactionMode) => async (request) => {
+            const response = new Response(null, {
+                status: 307,
+            });
+            const session = await edge.getIronSession(request, response, this.ironSessionConfigs);
+            const nodeClient = this.createNodeClient(session);
+            await nodeClient.signIn(redirectUri, interactionMode);
+            await this.storage?.save();
+            if (this.navigateUrl) {
+                response.headers.append('Location', this.navigateUrl);
+            }
+            return response;
+        };
+        this.handleSignOut = (redirectUri = this.config.baseUrl) => async (request) => {
+            const response = new Response(null, {
+                status: 307,
+            });
+            const session = await edge.getIronSession(request, response, this.ironSessionConfigs);
+            const nodeClient = this.createNodeClient(session);
+            await nodeClient.signOut(redirectUri);
+            session.destroy();
+            await this.storage?.save();
+            if (this.navigateUrl) {
+                response.headers.append('Location', this.navigateUrl);
+            }
+            return response;
+        };
+        this.handleSignInCallback = (redirectTo = this.config.baseUrl) => async (request) => {
+            const response = new Response(null, {
+                status: 307,
+                headers: {
+                    Location: redirectTo,
+                },
+            });
+            const session = await edge.getIronSession(request, response, this.ironSessionConfigs);
+            const nodeClient = this.createNodeClient(session);
+            if (request.url) {
+                await nodeClient.handleSignInCallback(request.url);
+                await this.storage?.save();
+            }
+            return response;
+        };
+        this.handleUser = (configs) => async (request) => {
+            const context = await this.getLogtoContext(request, configs);
+            return new Response(JSON.stringify(context), {
+                status: 200,
+                headers: {
+                    'content-type': 'application/json',
+                },
+            });
+        };
+        this.getLogtoContext = async (request, config = {}) => {
+            const session = await edge.getIronSession(request, new Response(), this.ironSessionConfigs);
+            const context = await this.getLogtoUserFromRequest(session, config);
+            return context;
+        };
+    }
+}
+
+exports.default = LogtoClient;

package/lib/edge/index.d.ts

@@ -0,0 +1,13 @@
+import { type GetContextParameters, type InteractionMode } from '@logto/node';
+import { type NextRequest } from 'next/server';
+import BaseClient from '../src/client';
+import type { LogtoNextConfig } from '../src/types.js';
+export type { LogtoContext, InteractionMode } from '@logto/node';
+export default class LogtoClient extends BaseClient {
+    constructor(config: LogtoNextConfig);
+    handleSignIn: (redirectUri?: string, interactionMode?: InteractionMode) => (request: NextRequest) => Promise<Response>;
+    handleSignOut: (redirectUri?: string) => (request: NextRequest) => Promise<Response>;
+    handleSignInCallback: (redirectTo?: string) => (request: NextRequest) => Promise<Response>;
+    handleUser: (configs?: GetContextParameters) => (request: NextRequest) => Promise<Response>;
+    getLogtoContext: (request: NextRequest, config?: GetContextParameters) => Promise<import("@logto/node").LogtoContext>;
+}

package/lib/edge/index.js

@@ -0,0 +1,69 @@
+import NodeClient from '@logto/node/edge';
+import { getIronSession } from 'iron-session/edge';
+import LogtoNextBaseClient from '../src/client.js';
+
+class LogtoClient extends LogtoNextBaseClient {
+    constructor(config) {
+        super(config, {
+            NodeClient,
+        });
+        this.handleSignIn = (redirectUri = `${this.config.baseUrl}/api/logto/sign-in-callback`, interactionMode) => async (request) => {
+            const response = new Response(null, {
+                status: 307,
+            });
+            const session = await getIronSession(request, response, this.ironSessionConfigs);
+            const nodeClient = this.createNodeClient(session);
+            await nodeClient.signIn(redirectUri, interactionMode);
+            await this.storage?.save();
+            if (this.navigateUrl) {
+                response.headers.append('Location', this.navigateUrl);
+            }
+            return response;
+        };
+        this.handleSignOut = (redirectUri = this.config.baseUrl) => async (request) => {
+            const response = new Response(null, {
+                status: 307,
+            });
+            const session = await getIronSession(request, response, this.ironSessionConfigs);
+            const nodeClient = this.createNodeClient(session);
+            await nodeClient.signOut(redirectUri);
+            session.destroy();
+            await this.storage?.save();
+            if (this.navigateUrl) {
+                response.headers.append('Location', this.navigateUrl);
+            }
+            return response;
+        };
+        this.handleSignInCallback = (redirectTo = this.config.baseUrl) => async (request) => {
+            const response = new Response(null, {
+                status: 307,
+                headers: {
+                    Location: redirectTo,
+                },
+            });
+            const session = await getIronSession(request, response, this.ironSessionConfigs);
+            const nodeClient = this.createNodeClient(session);
+            if (request.url) {
+                await nodeClient.handleSignInCallback(request.url);
+                await this.storage?.save();
+            }
+            return response;
+        };
+        this.handleUser = (configs) => async (request) => {
+            const context = await this.getLogtoContext(request, configs);
+            return new Response(JSON.stringify(context), {
+                status: 200,
+                headers: {
+                    'content-type': 'application/json',
+                },
+            });
+        };
+        this.getLogtoContext = async (request, config = {}) => {
+            const session = await getIronSession(request, new Response(), this.ironSessionConfigs);
+            const context = await this.getLogtoUserFromRequest(session, config);
+            return context;
+        };
+    }
+}
+
+export { LogtoClient as default };

package/lib/src/client.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var storage = require('./storage.cjs');
+
+class LogtoNextBaseClient {
+    constructor(config, adapters) {
+        this.config = config;
+        this.adapters = adapters;
+    }
+    createNodeClient(session) {
+        this.storage = new storage.default(session);
+        return new this.adapters.NodeClient(this.config, {
+            storage: this.storage,
+            navigate: (url) => {
+                this.navigateUrl = url;
+            },
+        });
+    }
+    get ironSessionConfigs() {
+        return {
+            cookieName: `logto:${this.config.appId}`,
+            password: this.config.cookieSecret,
+            cookieOptions: {
+                secure: this.config.cookieSecure,
+                maxAge: 14 * 24 * 60 * 60,
+            },
+        };
+    }
+    async getLogtoUserFromRequest(session, configs) {
+        const nodeClient = this.createNodeClient(session);
+        return nodeClient.getContext(configs);
+    }
+}
+
+exports.default = LogtoNextBaseClient;

package/lib/src/client.d.ts

@@ -0,0 +1,21 @@
+import type { GetContextParameters } from '@logto/node';
+import { type IronSession } from 'iron-session';
+import NextStorage from './storage';
+import type { Adapters, LogtoNextConfig } from './types';
+export default class LogtoNextBaseClient {
+    protected readonly config: LogtoNextConfig;
+    protected readonly adapters: Adapters;
+    protected navigateUrl?: string;
+    protected storage?: NextStorage;
+    constructor(config: LogtoNextConfig, adapters: Adapters);
+    protected createNodeClient(session: IronSession): import("@logto/node").default;
+    protected get ironSessionConfigs(): {
+        cookieName: string;
+        password: string;
+        cookieOptions: {
+            secure: boolean;
+            maxAge: number;
+        };
+    };
+    protected getLogtoUserFromRequest(session: IronSession, configs: GetContextParameters): Promise<import("@logto/node").LogtoContext>;
+}

package/lib/src/client.js

@@ -0,0 +1,33 @@
+import NextStorage from './storage.js';
+
+class LogtoNextBaseClient {
+    constructor(config, adapters) {
+        this.config = config;
+        this.adapters = adapters;
+    }
+    createNodeClient(session) {
+        this.storage = new NextStorage(session);
+        return new this.adapters.NodeClient(this.config, {
+            storage: this.storage,
+            navigate: (url) => {
+                this.navigateUrl = url;
+            },
+        });
+    }
+    get ironSessionConfigs() {
+        return {
+            cookieName: `logto:${this.config.appId}`,
+            password: this.config.cookieSecret,
+            cookieOptions: {
+                secure: this.config.cookieSecure,
+                maxAge: 14 * 24 * 60 * 60,
+            },
+        };
+    }
+    async getLogtoUserFromRequest(session, configs) {
+        const nodeClient = this.createNodeClient(session);
+        return nodeClient.getContext(configs);
+    }
+}
+
+export { LogtoNextBaseClient as default };

package/lib/{index.js → src/index.cjs}

@@ -4,17 +4,19 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var NodeClient = require('@logto/node');
 var next = require('iron-session/next');
-var storage = require('./storage.js');
+var client = require('./client.cjs');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var NodeClient__default = /*#__PURE__*/_interopDefault(NodeClient);
 
-class LogtoClient {
+class LogtoClient extends client.default {
     constructor(config) {
-        this.config = config;
+        super(config, {
+            NodeClient: NodeClient__default.default,
+        });
         this.handleSignIn = (redirectUri = `${this.config.baseUrl}/api/logto/sign-in-callback`, interactionMode) => next.withIronSessionApiRoute(async (request, response) => {
-            const nodeClient = this.createNodeClient(request);
+            const nodeClient = this.createNodeClient(request.session);
             await nodeClient.signIn(redirectUri, interactionMode);
             await this.storage?.save();
             if (this.navigateUrl) {
@@ -22,7 +24,7 @@ class LogtoClient {
             }
         }, this.ironSessionConfigs);
         this.handleSignInCallback = (redirectTo = this.config.baseUrl) => next.withIronSessionApiRoute(async (request, response) => {
-            const nodeClient = this.createNodeClient(request);
+            const nodeClient = this.createNodeClient(request.session);
             if (request.url) {
                 await nodeClient.handleSignInCallback(`${this.config.baseUrl}${request.url}`);
                 await this.storage?.save();
@@ -30,7 +32,7 @@ class LogtoClient {
             }
         }, this.ironSessionConfigs);
         this.handleSignOut = (redirectUri = this.config.baseUrl) => next.withIronSessionApiRoute(async (request, response) => {
-            const nodeClient = this.createNodeClient(request);
+            const nodeClient = this.createNodeClient(request.session);
             await nodeClient.signOut(redirectUri);
             request.session.destroy();
             await this.storage?.save();
@@ -61,41 +63,18 @@ class LogtoClient {
             response.status(404).end();
         };
         this.withLogtoApiRoute = (handler, config = {}) => next.withIronSessionApiRoute(async (request, response) => {
-            const user = await this.getLogtoUserFromRequest(request, config);
+            const user = await this.getLogtoUserFromRequest(request.session, config);
             // eslint-disable-next-line @silverhand/fp/no-mutating-methods
             Object.defineProperty(request, 'user', { enumerable: true, get: () => user });
             return handler(request, response);
         }, this.ironSessionConfigs);
         this.withLogtoSsr = (handler, configs = {}) => next.withIronSessionSsr(async (context) => {
-            const user = await this.getLogtoUserFromRequest(context.req, configs);
+            const user = await this.getLogtoUserFromRequest(context.req.session, configs);
             // eslint-disable-next-line @silverhand/fp/no-mutating-methods
             Object.defineProperty(context.req, 'user', { enumerable: true, get: () => user });
             return handler(context);
         }, this.ironSessionConfigs);
     }
-    createNodeClient(request) {
-        this.storage = new storage.default(request);
-        return new NodeClient__default.default(this.config, {
-            storage: this.storage,
-            navigate: (url) => {
-                this.navigateUrl = url;
-            },
-        });
-    }
-    get ironSessionConfigs() {
-        return {
-            cookieName: `logto:${this.config.appId}`,
-            password: this.config.cookieSecret,
-            cookieOptions: {
-                secure: this.config.cookieSecure,
-                maxAge: 14 * 24 * 60 * 60,
-            },
-        };
-    }
-    async getLogtoUserFromRequest(request, configs) {
-        const nodeClient = this.createNodeClient(request);
-        return nodeClient.getContext(configs);
-    }
 }
 
 Object.defineProperty(exports, 'ReservedScope', {

package/lib/{index.d.ts → src/index.d.ts}

@@ -1,12 +1,10 @@
-import type { GetContextParameters, InteractionMode } from '@logto/node';
-import type { GetServerSidePropsContext, GetServerSidePropsResult, NextApiHandler } from 'next';
-import type { LogtoNextConfig } from './types';
+import { type GetContextParameters, type InteractionMode } from '@logto/node';
+import { type GetServerSidePropsResult, type GetServerSidePropsContext, type NextApiHandler } from 'next';
+import LogtoNextBaseClient from './client.js';
+import type { LogtoNextConfig } from './types.js';
 export { ReservedScope, UserScope } from '@logto/node';
 export type { LogtoContext, InteractionMode } from '@logto/node';
-export default class LogtoClient {
-    private readonly config;
-    private navigateUrl?;
-    private storage?;
+export default class LogtoClient extends LogtoNextBaseClient {
     constructor(config: LogtoNextConfig);
     handleSignIn: (redirectUri?: string, interactionMode?: InteractionMode) => NextApiHandler;
     handleSignInCallback: (redirectTo?: string) => NextApiHandler;
@@ -15,7 +13,4 @@ export default class LogtoClient {
     handleAuthRoutes: (configs?: GetContextParameters) => NextApiHandler;
     withLogtoApiRoute: (handler: NextApiHandler, config?: GetContextParameters) => NextApiHandler;
     withLogtoSsr: <P extends Record<string, unknown> = Record<string, unknown>>(handler: (context: GetServerSidePropsContext) => GetServerSidePropsResult<P> | Promise<GetServerSidePropsResult<P>>, configs?: GetContextParameters) => (context: GetServerSidePropsContext) => Promise<GetServerSidePropsResult<P>>;
-    private createNodeClient;
-    private get ironSessionConfigs();
-    private getLogtoUserFromRequest;
 }

package/lib/{index.mjs → src/index.js}

@@ -1,13 +1,15 @@
 import NodeClient from '@logto/node';
 export { ReservedScope, UserScope } from '@logto/node';
 import { withIronSessionApiRoute, withIronSessionSsr } from 'iron-session/next';
-import NextStorage from './storage.mjs';
+import LogtoNextBaseClient from './client.js';
 
-class LogtoClient {
+class LogtoClient extends LogtoNextBaseClient {
     constructor(config) {
-        this.config = config;
+        super(config, {
+            NodeClient,
+        });
         this.handleSignIn = (redirectUri = `${this.config.baseUrl}/api/logto/sign-in-callback`, interactionMode) => withIronSessionApiRoute(async (request, response) => {
-            const nodeClient = this.createNodeClient(request);
+            const nodeClient = this.createNodeClient(request.session);
             await nodeClient.signIn(redirectUri, interactionMode);
             await this.storage?.save();
             if (this.navigateUrl) {
@@ -15,7 +17,7 @@ class LogtoClient {
             }
         }, this.ironSessionConfigs);
         this.handleSignInCallback = (redirectTo = this.config.baseUrl) => withIronSessionApiRoute(async (request, response) => {
-            const nodeClient = this.createNodeClient(request);
+            const nodeClient = this.createNodeClient(request.session);
             if (request.url) {
                 await nodeClient.handleSignInCallback(`${this.config.baseUrl}${request.url}`);
                 await this.storage?.save();
@@ -23,7 +25,7 @@ class LogtoClient {
             }
         }, this.ironSessionConfigs);
         this.handleSignOut = (redirectUri = this.config.baseUrl) => withIronSessionApiRoute(async (request, response) => {
-            const nodeClient = this.createNodeClient(request);
+            const nodeClient = this.createNodeClient(request.session);
             await nodeClient.signOut(redirectUri);
             request.session.destroy();
             await this.storage?.save();
@@ -54,41 +56,18 @@ class LogtoClient {
             response.status(404).end();
         };
         this.withLogtoApiRoute = (handler, config = {}) => withIronSessionApiRoute(async (request, response) => {
-            const user = await this.getLogtoUserFromRequest(request, config);
+            const user = await this.getLogtoUserFromRequest(request.session, config);
             // eslint-disable-next-line @silverhand/fp/no-mutating-methods
             Object.defineProperty(request, 'user', { enumerable: true, get: () => user });
             return handler(request, response);
         }, this.ironSessionConfigs);
         this.withLogtoSsr = (handler, configs = {}) => withIronSessionSsr(async (context) => {
-            const user = await this.getLogtoUserFromRequest(context.req, configs);
+            const user = await this.getLogtoUserFromRequest(context.req.session, configs);
             // eslint-disable-next-line @silverhand/fp/no-mutating-methods
             Object.defineProperty(context.req, 'user', { enumerable: true, get: () => user });
             return handler(context);
         }, this.ironSessionConfigs);
     }
-    createNodeClient(request) {
-        this.storage = new NextStorage(request);
-        return new NodeClient(this.config, {
-            storage: this.storage,
-            navigate: (url) => {
-                this.navigateUrl = url;
-            },
-        });
-    }
-    get ironSessionConfigs() {
-        return {
-            cookieName: `logto:${this.config.appId}`,
-            password: this.config.cookieSecret,
-            cookieOptions: {
-                secure: this.config.cookieSecure,
-                maxAge: 14 * 24 * 60 * 60,
-            },
-        };
-    }
-    async getLogtoUserFromRequest(request, configs) {
-        const nodeClient = this.createNodeClient(request);
-        return nodeClient.getContext(configs);
-    }
 }
 
 export { LogtoClient as default };

package/lib/{storage.js → src/storage.cjs}

@@ -3,30 +3,30 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 class NextStorage {
-    constructor(request) {
-        this.request = request;
+    constructor(session) {
+        this.session = session;
         this.sessionChanged = false;
     }
     async setItem(key, value) {
-        this.request.session[key] = value;
+        this.session[key] = value;
         this.sessionChanged = true;
     }
     async getItem(key) {
-        const value = this.request.session[key];
+        const value = this.session[key];
         if (value === undefined) {
             return null;
         }
         return String(value);
     }
     async removeItem(key) {
-        this.request.session[key] = undefined;
+        this.session[key] = undefined;
         this.sessionChanged = true;
     }
     async save() {
         if (!this.sessionChanged) {
             return;
         }
-        await this.request.session.save();
+        await this.session.save();
         this.sessionChanged = false;
     }
 }

package/lib/{storage.d.ts → src/storage.d.ts}

@@ -1,9 +1,9 @@
-import type { IncomingMessage } from 'http';
 import type { Storage, StorageKey } from '@logto/node';
+import { type IronSession } from 'iron-session';
 export default class NextStorage implements Storage {
-    private readonly request;
+    private readonly session;
     private sessionChanged;
-    constructor(request: IncomingMessage);
+    constructor(session: IronSession);
     setItem(key: StorageKey, value: string): Promise<void>;
     getItem(key: StorageKey): Promise<string | null>;
     removeItem(key: StorageKey): Promise<void>;

package/lib/{storage.mjs → src/storage.js}

@@ -1,28 +1,28 @@
 class NextStorage {
-    constructor(request) {
-        this.request = request;
+    constructor(session) {
+        this.session = session;
         this.sessionChanged = false;
     }
     async setItem(key, value) {
-        this.request.session[key] = value;
+        this.session[key] = value;
         this.sessionChanged = true;
     }
     async getItem(key) {
-        const value = this.request.session[key];
+        const value = this.session[key];
         if (value === undefined) {
             return null;
         }
         return String(value);
     }
     async removeItem(key) {
-        this.request.session[key] = undefined;
+        this.session[key] = undefined;
         this.sessionChanged = true;
     }
     async save() {
         if (!this.sessionChanged) {
             return;
         }
-        await this.request.session.save();
+        await this.session.save();
         this.sessionChanged = false;
     }
 }

package/lib/{types.d.ts → src/types.d.ts}

@@ -1,4 +1,5 @@
 import type { LogtoConfig } from '@logto/node';
+import type NodeClient from '@logto/node';
 import type { IronSession } from 'iron-session';
 import type { NextApiRequest } from 'next';
 export type NextRequestWithIronSession = NextApiRequest & {
@@ -17,3 +18,6 @@ export type LogtoNextConfig = LogtoConfig & {
     cookieSecure: boolean;
     baseUrl: string;
 };
+export type Adapters = {
+    NodeClient: typeof NodeClient;
+};

package/package.json

@@ -1,14 +1,22 @@
 {
   "name": "@logto/next",
-  "version": "1.1.2",
-  "source": "./src/index.ts",
-  "main": "./lib/index.js",
+  "version": "2.1.0",
+  "type": "module",
+  "main": "./lib/src/index.cjs",
+  "module": "./lib/src/index.js",
+  "types": "./lib/src/index.d.ts",
   "exports": {
-    "require": "./lib/index.js",
-    "import": "./lib/index.mjs"
+    ".": {
+      "require": "./lib/src/index.cjs",
+      "import": "./lib/src/index.js",
+      "types": "./lib/src/index.d.ts"
+    },
+    "./edge": {
+      "require": "./lib/edge/index.cjs",
+      "import": "./lib/edge/index.js",
+      "types": "./lib/edge/index.d.ts"
+    }
   },
-  "module": "./lib/index.mjs",
-  "types": "./lib/index.d.ts",
   "files": [
     "lib"
   ],
@@ -18,25 +26,14 @@
     "url": "https://github.com/logto-io/js.git",
     "directory": "packages/next"
   },
-  "scripts": {
-    "dev:tsc": "tsc -p tsconfig.build.json -w --preserveWatchOutput",
-    "precommit": "lint-staged",
-    "check": "tsc --noEmit",
-    "build": "rm -rf lib/ && tsc -p tsconfig.build.json --noEmit && rollup -c",
-    "lint": "eslint --ext .ts src",
-    "test": "jest",
-    "test:coverage": "jest --silent --coverage",
-    "prepack": "pnpm test"
-  },
   "dependencies": {
-    "@logto/node": "^1.1.2",
-    "iron-session": "^6.1.3"
+    "@logto/node": "^2.1.0",
+    "iron-session": "^6.3.1"
   },
   "devDependencies": {
-    "@jest/types": "^29.5.0",
-    "@silverhand/eslint-config": "^2.0.0",
-    "@silverhand/ts-config": "^1.0.0",
-    "@silverhand/ts-config-react": "^2.0.0",
+    "@silverhand/eslint-config": "^3.0.1",
+    "@silverhand/ts-config": "^3.0.0",
+    "@silverhand/ts-config-react": "^3.0.0",
     "@swc/core": "^1.3.50",
     "@swc/jest": "^0.2.24",
     "@types/jest": "^29.5.0",
@@ -45,30 +42,33 @@
     "jest-location-mock": "^1.0.9",
     "jest-matcher-specific-error": "^1.0.0",
     "lint-staged": "^13.0.0",
-    "next": "^12.2.2",
+    "next": "^13.0.4",
     "next-test-api-route-handler": "^3.1.6",
     "prettier": "^2.8.7",
-    "react": "^17.0.2",
-    "react-dom": "^17.0.2",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
     "typescript": "^5.0.0"
   },
   "peerDependencies": {
     "next": ">=12"
   },
   "eslintConfig": {
-    "extends": "@silverhand"
+    "extends": "@silverhand",
+    "rules": {
+      "unicorn/prefer-node-protocol": "off"
+    }
   },
   "prettier": "@silverhand/eslint-config/.prettierrc",
   "publishConfig": {
     "access": "public"
   },
-  "targets": {
-    "main": {
-      "context": "node",
-      "engines": {
-        "node": ">=18.12.0"
-      }
-    }
-  },
-  "gitHead": "9e9a8b0887ef67baa7c3c564590bb06e7801d03e"
-}
+  "scripts": {
+    "dev:tsc": "tsc -p tsconfig.build.json -w --preserveWatchOutput",
+    "precommit": "lint-staged",
+    "check": "tsc --noEmit",
+    "build": "rm -rf lib/ && tsc -p tsconfig.build.json --noEmit && rollup -c",
+    "lint": "eslint --ext .ts src",
+    "test": "jest",
+    "test:coverage": "node test.cjs && jest --silent --coverage"
+  }
+}