@neon-rs/manifest 0.0.2 → 0.0.4

package/lib/library/legacy.cjs

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLibraryCfg = void 0;
+const platform_cjs_1 = require("../platform.cjs");
+const util_cjs_1 = require("../util.cjs");
+const neon_cjs_1 = require("./neon.cjs");
+function assertIsLibraryV1(json) {
+    (0, util_cjs_1.assertIsObject)(json, "neon");
+    for (const key in json) {
+        const value = json[key];
+        if (!(0, platform_cjs_1.isRustTarget)(key)) {
+            throw new TypeError(`target table key ${key} is not a valid Rust target`);
+        }
+        if (typeof value !== 'string') {
+            throw new TypeError(`target table value ${value} is not a string`);
+        }
+    }
+}
+function normalizeLibraryCfg(json) {
+    (0, neon_cjs_1.assertHasNeonCfg)(json);
+    // V5 format: {
+    //   type: 'library',
+    //   org: string,
+    //   platforms: PlatformFamily,
+    //   load?: string | undefined
+    // }
+    if ('type' in json.neon && json.neon.type === 'library') {
+        return false;
+    }
+    // V4 format: {
+    //   neon: {
+    //     type: 'source',
+    //     org: string,
+    //     platforms: PlatformFamily,
+    //     load?: string | undefined
+    //   }
+    // }
+    if ('type' in json.neon && 'platforms' in json.neon) {
+        json.neon.type = 'library';
+        return true;
+    }
+    // V3 format: {
+    //   neon: {
+    //     type: 'source',
+    //     org: string,
+    //     targets: PlatformFamily
+    //   }
+    // }
+    if ('type' in json.neon) {
+        const org = json.neon['org'];
+        const targets = json.neon['targets'];
+        (0, platform_cjs_1.assertIsPlatformFamily)(targets, "neon.targets");
+        json.neon = {
+            type: 'library',
+            org,
+            platforms: targets
+        };
+        return true;
+    }
+    // V2 format: {
+    //   neon: {
+    //     org: string,
+    //     targets: { Node => Rust }
+    //   }
+    // }
+    if ('org' in json.neon) {
+        const platforms = json.neon['targets'];
+        (0, platform_cjs_1.assertIsPlatformMap)(platforms, "neon.targets");
+        json.neon = {
+            type: 'library',
+            org: json.neon.org,
+            platforms
+        };
+        return true;
+    }
+    // V1 format: {
+    //   neon: {
+    //     targets: { Rust => fully-qualified package name }
+    //   }
+    // }
+    const targets = json.neon['targets'];
+    assertIsLibraryV1(targets);
+    json.neon = upgradeLibraryV1(targets);
+    return true;
+}
+exports.normalizeLibraryCfg = normalizeLibraryCfg;
+function upgradeLibraryV1(object) {
+    function splitSwap([key, value]) {
+        if (!/^@.*\//.test(value)) {
+            throw new TypeError(`expected namespaced npm package name, found ${value}`);
+        }
+        const pkg = value.split('/')[1];
+        (0, platform_cjs_1.assertIsNodePlatform)(pkg);
+        (0, platform_cjs_1.assertIsRustTarget)(key);
+        return [pkg, key];
+    }
+    const entries = Object.entries(object).map(splitSwap);
+    const orgs = new Set(Object.values(object).map(v => v.split('/')[0]));
+    if (orgs.size === 0) {
+        throw new Error("empty target table");
+    }
+    else if (orgs.size > 1) {
+        throw new Error(`multiple npm orgs found: ${orgs}`);
+    }
+    return {
+        type: 'library',
+        org: [...orgs][0],
+        platforms: Object.fromEntries(entries)
+    };
+}

package/lib/library/legacy.d.cts

@@ -0,0 +1 @@
+export declare function normalizeLibraryCfg(json: object): boolean;

package/lib/library/library.cjs

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LibraryManifest = exports.SCHEMA_VERSION = void 0;
+const platform_cjs_1 = require("../platform.cjs");
+const neon_cjs_1 = require("./neon.cjs");
+const util_cjs_1 = require("../util.cjs");
+const legacy_cjs_1 = require("./legacy.cjs");
+const npm_cjs_1 = require("../cache/npm/npm.cjs");
+function assertIsLibraryCfg(json) {
+    (0, util_cjs_1.assertHasProps)(['type', 'org', 'platforms'], json, "neon");
+    if (json.type !== 'library') {
+        throw new TypeError(`expected "neon.type" property to be "library", found ${json.type}`);
+    }
+    if (typeof json.org !== 'string') {
+        throw new TypeError(`expected "neon.org" to be a string, found ${json.org}`);
+    }
+    (0, platform_cjs_1.assertIsPlatformFamily)(json.platforms, "neon.platforms");
+    if ('load' in json) {
+        if (typeof json.load !== 'string' && typeof json.load !== 'undefined') {
+            throw new TypeError(`expected "neon.load" to be a string, found ${json.load}`);
+        }
+    }
+}
+function assertHasLibraryCfg(json) {
+    (0, neon_cjs_1.assertHasNeonCfg)(json);
+    assertIsLibraryCfg(json.neon);
+}
+exports.SCHEMA_VERSION = 5;
+// The source manifest is the source of truth for all Neon
+// project metadata. This means you never need to go searching
+// for any other files to query the Neon project's metadata.
+// (Some data is replicated in the binary manifests, however,
+// since they are independently published in npm.)
+class LibraryManifest extends util_cjs_1.AbstractManifest {
+    constructor(dir, json) {
+        super(json);
+        this.dir = dir;
+        this._normalized = (0, legacy_cjs_1.normalizeLibraryCfg)(this._json);
+        this._updatedPlatforms = false;
+        assertHasLibraryCfg(this._json);
+        this._sourceJSON = this._json;
+        this._expandedPlatforms = (0, platform_cjs_1.expandPlatformFamily)(this._sourceJSON.neon.platforms);
+        this._cacheCfg = ('org' in this._sourceJSON.neon) ? new npm_cjs_1.NPMCacheCfg(this) : null;
+    }
+    hasUnsavedChanges() {
+        return this._normalized ||
+            this._updatedPlatforms ||
+            !!(this._cacheCfg && this._cacheCfg.hasUnsavedChanges());
+    }
+    static async load(dir = process.cwd()) {
+        return new LibraryManifest(dir, await (0, util_cjs_1.readManifest)(dir));
+    }
+    async saveChanges(log) {
+        if (!this.hasUnsavedChanges()) {
+            return;
+        }
+        await this.save(log);
+        if (this._cacheCfg) {
+            await this._cacheCfg.saveChanges(log);
+        }
+        this._normalized = false;
+        this._updatedPlatforms = false;
+    }
+    get preamble() {
+        return this._json;
+    }
+    cfg() {
+        return this._sourceJSON.neon;
+    }
+    allPlatforms() {
+        return this._expandedPlatforms;
+    }
+    async addTargetPair(pair) {
+        const { node, rust } = pair;
+        if (this._expandedPlatforms[node] === rust) {
+            return;
+        }
+        this._expandedPlatforms[node] = rust;
+        if (this._cacheCfg) {
+            this._cacheCfg.setPlatformTarget(node, rust);
+        }
+    }
+    async addNodePlatform(platform) {
+        const targets = (0, platform_cjs_1.node2Rust)(platform);
+        if (targets.length > 1) {
+            throw new Error(`multiple Rust targets found for Node platform ${platform}; please specify one of ${targets.join(', ')}`);
+        }
+        await this.addTargetPair({ node: platform, rust: targets[0] });
+    }
+    async addRustTarget(target) {
+        await this.addTargetPair({ node: (0, platform_cjs_1.rust2Node)(target), rust: target });
+    }
+    filterChanges(family) {
+        let changes = Object.create(null);
+        for (const [key, value] of Object.entries(family)) {
+            const node = key;
+            const rust = value;
+            if (this._expandedPlatforms[node] === rust) {
+                continue;
+            }
+            changes[node] = rust;
+        }
+        return changes;
+    }
+    async addPlatforms(map) {
+        let changes = this.filterChanges(map);
+        for (const [key, value] of Object.entries(changes)) {
+            const node = key;
+            const rust = value;
+            if (this._cacheCfg) {
+                await this._cacheCfg.setPlatformTarget(node, rust);
+            }
+            this._expandedPlatforms[node] = rust;
+        }
+        return changes;
+    }
+    async addPlatformPreset(preset) {
+        const platformsSrc = this.cfg().platforms;
+        if (typeof platformsSrc === 'string') {
+            this.cfg().platforms = [platformsSrc, preset];
+            await this.addPlatforms((0, platform_cjs_1.expandPlatformFamily)(preset));
+        }
+        else if (Array.isArray(platformsSrc)) {
+            platformsSrc.push(preset);
+            await this.addPlatforms((0, platform_cjs_1.expandPlatformFamily)(preset));
+        }
+        // Edge case: an empty object can be treated like an empty array
+        else if (Object.keys(platformsSrc).length === 0) {
+            this.cfg().platforms = [];
+            await this.addPlatformPreset(preset);
+        }
+        else {
+            const added = await this.addPlatforms((0, platform_cjs_1.expandPlatformFamily)(preset));
+            Object.assign(platformsSrc, added);
+        }
+    }
+    updatePlatforms() {
+        if (this._cacheCfg && this._cacheCfg.updatePlatforms(this)) {
+            this._updatedPlatforms = true;
+        }
+    }
+}
+exports.LibraryManifest = LibraryManifest;

package/lib/library/library.d.cts

@@ -0,0 +1,31 @@
+import { PlatformFamily, PlatformMap, PlatformPreset, NodePlatform, RustTarget, TargetPair } from "../platform.cjs";
+import { AbstractManifest, Preamble } from "../util.cjs";
+export interface LibraryCfg {
+    type: "library";
+    org: string;
+    platforms: PlatformFamily;
+    load?: string;
+}
+export declare const SCHEMA_VERSION = 5;
+export declare class LibraryManifest extends AbstractManifest {
+    private _sourceJSON;
+    private _expandedPlatforms;
+    private _cacheCfg;
+    private _normalized;
+    private _updatedPlatforms;
+    readonly dir: string;
+    constructor(dir: string, json: Preamble);
+    hasUnsavedChanges(): boolean;
+    static load(dir?: string): Promise<LibraryManifest>;
+    saveChanges(log: (msg: string) => void): Promise<void>;
+    get preamble(): Preamble;
+    cfg(): LibraryCfg;
+    allPlatforms(): PlatformMap;
+    addTargetPair(pair: TargetPair): Promise<void>;
+    addNodePlatform(platform: NodePlatform): Promise<void>;
+    addRustTarget(target: RustTarget): Promise<void>;
+    private filterChanges;
+    private addPlatforms;
+    addPlatformPreset(preset: PlatformPreset): Promise<void>;
+    updatePlatforms(): void;
+}

package/lib/library/neon.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertHasNeonCfg = void 0;
+const util_cjs_1 = require("../util.cjs");
+function assertHasNeonCfg(json) {
+    if (!('neon' in json)) {
+        throw new TypeError('property "neon" not found');
+    }
+    (0, util_cjs_1.assertIsObject)(json.neon, "neon");
+}
+exports.assertHasNeonCfg = assertHasNeonCfg;

package/lib/library/neon.d.cts

@@ -0,0 +1,4 @@
+export type HasNeonCfg = {
+    neon: object;
+};
+export declare function assertHasNeonCfg(json: object): asserts json is HasNeonCfg;

package/lib/neon.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertHasNeonCfg = void 0;
+const util_cjs_1 = require("./util.cjs");
+function assertHasNeonCfg(json) {
+    if (!('neon' in json)) {
+        throw new TypeError('property "neon" not found');
+    }
+    (0, util_cjs_1.assertIsObject)(json.neon, "neon");
+}
+exports.assertHasNeonCfg = assertHasNeonCfg;

package/lib/neon.d.cts

@@ -0,0 +1,4 @@
+export type HasNeonCfg = {
+    neon: object;
+};
+export declare function assertHasNeonCfg(json: object): asserts json is HasNeonCfg;

package/lib/platform.cjs

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rust2Node = exports.node2Rust = exports.getTargetDescriptor = exports.expandPlatformFamily = exports.expandPlatformPreset = exports.assertIsPlatformPreset = exports.isPlatformPreset = exports.assertIsNodePlatform = exports.isNodePlatform = exports.assertIsRustTarget = exports.isRustTarget = void 0;
+exports.rust2Node = exports.node2Rust = exports.describeTarget = exports.expandPlatformFamily = exports.expandPlatformPreset = exports.assertIsPlatformFamily = exports.assertIsPlatformMap = exports.assertIsPlatformPreset = exports.isPlatformPreset = exports.assertIsNodePlatform = exports.isNodePlatform = exports.assertIsRustTarget = exports.isRustTarget = void 0;
 const rust_json_1 = __importDefault(require("../data/rust.json"));
 const node_json_1 = __importDefault(require("../data/node.json"));
 const preset_json_1 = __importDefault(require("../data/preset.json"));
+const util_cjs_1 = require("./util.cjs");
 function isRustTarget(x) {
     return (typeof x === 'string') && (x in rust_json_1.default);
 }
@@ -37,6 +38,33 @@ function assertIsPlatformPreset(x) {
     }
 }
 exports.assertIsPlatformPreset = assertIsPlatformPreset;
+function assertIsPlatformMap(json, path) {
+    (0, util_cjs_1.assertIsObject)(json, path);
+    for (const key in json) {
+        const value = json[key];
+        if (!isNodePlatform(key)) {
+            throw new TypeError(`platform table key ${key} is not a valid Node platform`);
+        }
+        if (typeof value !== 'string' || !isRustTarget(value)) {
+            throw new TypeError(`platform table value ${value} is not a valid Rust target`);
+        }
+    }
+}
+exports.assertIsPlatformMap = assertIsPlatformMap;
+function assertIsPlatformFamily(json, path) {
+    if (typeof json === 'string') {
+        assertIsPlatformPreset(json);
+        return;
+    }
+    if (Array.isArray(json)) {
+        for (const elt of json) {
+            assertIsPlatformPreset(elt);
+        }
+        return;
+    }
+    assertIsPlatformMap(json, path);
+}
+exports.assertIsPlatformFamily = assertIsPlatformFamily;
 function lookupPlatformPreset(key) {
     return preset_json_1.default[key];
 }
@@ -59,7 +87,7 @@ function expandPlatformFamily(family) {
             : family;
 }
 exports.expandPlatformFamily = expandPlatformFamily;
-function getTargetDescriptor(target) {
+function describeTarget(target) {
     const node = rust_json_1.default[target];
     if (!isNodePlatform(node)) {
         throw new Error(`Rust target ${target} not supported`);
@@ -77,7 +105,7 @@ function getTargetDescriptor(target) {
         llvm: nodeDescriptor.llvm
     };
 }
-exports.getTargetDescriptor = getTargetDescriptor;
+exports.describeTarget = describeTarget;
 function node2Rust(target) {
     return node_json_1.default[target].llvm.map(rt => {
         assertIsRustTarget(rt);

package/lib/platform.d.cts

@@ -10,6 +10,8 @@ export declare function assertIsNodePlatform(x: unknown): asserts x is NodePlatf
 export type PlatformPreset = keyof (typeof PRESET);
 export declare function isPlatformPreset(x: unknown): x is PlatformPreset;
 export declare function assertIsPlatformPreset(x: unknown): asserts x is PlatformPreset;
+export declare function assertIsPlatformMap(json: unknown, path: string): asserts json is PlatformMap;
+export declare function assertIsPlatformFamily(json: unknown, path: string): asserts json is PlatformFamily;
 export type TargetPair = {
     node: NodePlatform;
     rust: RustTarget;
@@ -27,6 +29,6 @@ export type PlatformDescriptor = {
     abi: string | null;
     llvm: RustTarget[];
 };
-export declare function getTargetDescriptor(target: RustTarget): PlatformDescriptor;
+export declare function describeTarget(target: RustTarget): PlatformDescriptor;
 export declare function node2Rust(target: NodePlatform): RustTarget[];
 export declare function rust2Node(target: RustTarget): NodePlatform;

package/lib/platform.d.mts

@@ -1 +1 @@
-export { RustTarget, isRustTarget, assertIsRustTarget, NodePlatform, isNodePlatform, assertIsNodePlatform, PlatformPreset, isPlatformPreset, assertIsPlatformPreset, TargetPair, PlatformMap, PlatformFamily, expandPlatformPreset, expandPlatformFamily, PlatformDescriptor, getTargetDescriptor, node2Rust, rust2Node } from './platform.cjs';
+export { RustTarget, isRustTarget, assertIsRustTarget, NodePlatform, isNodePlatform, assertIsNodePlatform, PlatformPreset, isPlatformPreset, assertIsPlatformPreset, TargetPair, PlatformMap, assertIsPlatformMap, PlatformFamily, assertIsPlatformFamily, expandPlatformPreset, expandPlatformFamily, PlatformDescriptor, describeTarget, node2Rust, rust2Node } from './platform.cjs';

package/lib/platform.mjs

@@ -1 +1 @@
-export { isRustTarget, assertIsRustTarget, isNodePlatform, assertIsNodePlatform, isPlatformPreset, assertIsPlatformPreset, expandPlatformPreset, expandPlatformFamily, getTargetDescriptor, node2Rust, rust2Node } from './platform.cjs';
+export { isRustTarget, assertIsRustTarget, isNodePlatform, assertIsNodePlatform, isPlatformPreset, assertIsPlatformPreset, assertIsPlatformMap, assertIsPlatformFamily, expandPlatformPreset, expandPlatformFamily, describeTarget, node2Rust, rust2Node } from './platform.cjs';

package/lib/util.cjs

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractManifest = exports.readManifest = exports.assertHasProps = exports.assertIsObject = void 0;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+function assertIsObject(json, path) {
+    if (!json || typeof json !== 'object') {
+        throw new TypeError(`expected "${path}" property to be an object, found ${json}`);
+    }
+}
+exports.assertIsObject = assertIsObject;
+// Idea thanks to https://www.lucaspaganini.com/academy/assertion-functions-typescript-narrowing-5
+function assertHasProps(keys, json, path) {
+    assertIsObject(json, path);
+    for (const key of keys) {
+        if (!(key in json)) {
+            throw new TypeError(`property "${path}.${key}" not found`);
+        }
+    }
+}
+exports.assertHasProps = assertHasProps;
+async function readManifest(dir) {
+    dir = dir ?? process.cwd();
+    const json = JSON.parse(await fs.readFile(path.join(dir, "package.json"), { encoding: 'utf8' }));
+    assertIsPreamble(json);
+    return json;
+}
+exports.readManifest = readManifest;
+function assertIsPreamble(json) {
+    if (!json || typeof json !== 'object' || Array.isArray(json)) {
+        throw new TypeError(`expected Neon package manifest, found ${json}`);
+    }
+    if (!('version' in json) || typeof json.version !== 'string') {
+        throw new TypeError('valid "version" string not found in Neon package manifest');
+    }
+    if (!('name' in json) || typeof json.name !== 'string') {
+        throw new TypeError('valid "name" string not found in Neon package manifest');
+    }
+}
+const OPTIONAL_KEYS = [
+    'author', 'repository', 'keywords', 'bugs', 'homepage', 'license', 'engines'
+];
+class AbstractManifest {
+    constructor(json) {
+        this._json = json;
+    }
+    get name() { return this._json.name; }
+    set name(value) { this._json.name = value; }
+    get version() { return this._json.version; }
+    set version(value) { this._json.version = value; }
+    get description() { return this._json.description ?? ""; }
+    async save(log) {
+        await fs.writeFile(path.join(this.dir, "package.json"), JSON.stringify(this._json, null, 2), { encoding: 'utf8' });
+    }
+    stringify() {
+        return JSON.stringify(this._json);
+    }
+    toJSON() {
+        return JSON.parse(JSON.stringify(this._json));
+    }
+    copyOptionalKeys(target) {
+        for (const key of OPTIONAL_KEYS) {
+            if (key in this._json) {
+                target[key] = this._json[key];
+            }
+        }
+    }
+}
+exports.AbstractManifest = AbstractManifest;

package/lib/util.d.cts

@@ -0,0 +1,25 @@
+export declare function assertIsObject(json: unknown, path: string): asserts json is object;
+export declare function assertHasProps<K extends string>(keys: ReadonlyArray<K>, json: unknown, path: string): asserts json is Record<K, unknown>;
+export declare function readManifest(dir?: string | undefined): Promise<Preamble>;
+export type Preamble = {
+    name: string;
+    version: string;
+    optionalDependencies?: Record<string, string> | undefined;
+    [key: string]: any;
+};
+export declare abstract class AbstractManifest {
+    protected _json: Preamble;
+    abstract readonly dir: string;
+    constructor(json: Preamble);
+    get name(): string;
+    set name(value: string);
+    get version(): string;
+    set version(value: string);
+    get description(): string;
+    save(log: (msg: string) => void): Promise<void>;
+    stringify(): string;
+    toJSON(): unknown;
+    copyOptionalKeys(target: {
+        [key: string]: unknown;
+    }): void;
+}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@neon-rs/manifest",
   "private": false,
-  "version": "0.0.2",
-  "description": "",
+  "version": "0.0.4",
+  "description": "Library for working with Neon package configuration.",
   "exports": {
     ".": {
       "import": {
@@ -13,22 +13,30 @@
         "types": "./lib/index.d.cts",
         "default": "./lib/index.cjs"
       }
+    },
+    "./platform": {
+      "import": {
+        "types": "./lib/platform.d.mts",
+        "default": "./lib/platform.mjs"
+      },
+      "require": {
+        "types": "./lib/platform.d.cts",
+        "default": "./lib/platform.cjs"
+      }
     }
   },
   "types": "./lib/index.d.cts",
   "main": "./lib/index.cjs",
   "files": [
-    "lib/**/*.cjs",
-    "lib/**/*.d.cts",
-    "lib/**/*.mjs",
-    "lib/**/*.d.mts",
-    "lib/**/*.js",
-    "lib/**/*.d.ts",
+    "lib/*.?({c,m}){t,j}s",
+    "lib/!(test)/**/*",
     "data/**/*.json"
   ],
   "scripts": {
     "dist": "tsc",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "pretest": "npm run dist",
+    "test": "mocha",
+    "prepack": "npm run dist"
   },
   "keywords": [
     "Neon",
@@ -43,8 +51,13 @@
   "homepage": "https://github.com/dherman/neon-rs#readme",
   "devDependencies": {
     "@tsconfig/node16": "^16.1.1",
+    "@types/chai": "^4.3.12",
     "@types/jscodeshift": "^0.11.11",
+    "@types/mocha": "^10.0.6",
     "@types/node": "^20.11.10",
+    "chai": "^4.4.1",
+    "create-temp-directory": "^2.4.0",
+    "mocha": "^10.3.0",
     "typescript": "^5.3.3"
   },
   "dependencies": {