@wxn0brp/db-storage-dir 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 wxn0brP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# ValtheraDB Dir Storage
+
+This plugin provides directory-based operations for ValtheraDB.
+
+## Installation
+
+```bash
+npm install @wxn0brp/db-storage-dir
+```

package/dist/action.d.ts

@@ -0,0 +1,69 @@
+import dbActionBase from "@wxn0brp/db-core/base/actions";
+import Data from "@wxn0brp/db-core/types/data";
+import FileCpu from "@wxn0brp/db-core/types/fileCpu";
+import { DbOpts } from "@wxn0brp/db-core/types/options";
+import { VQuery } from "@wxn0brp/db-core/types/query";
+/**
+ * A class representing database actions on files.
+ * @class
+ */
+declare class dbActionC extends dbActionBase {
+    folder: string;
+    options: DbOpts;
+    fileCpu: FileCpu;
+    /**
+     * Creates a new instance of dbActionC.
+     * @constructor
+     * @param folder - The folder where database files are stored.
+     * @param options - The options object.
+     */
+    constructor(folder: string, options: DbOpts, fileCpu: FileCpu);
+    _getCollectionPath(collection: string): string;
+    /**
+     * Get a list of available databases in the specified folder.
+     */
+    getCollections(): Promise<string[]>;
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    checkCollection({ collection }: VQuery): Promise<boolean>;
+    /**
+     * Check if a collection exists.
+     */
+    issetCollection({ collection }: VQuery): Promise<boolean>;
+    /**
+     * Add a new entry to the specified database.
+     */
+    add({ collection, data, id_gen }: VQuery): Promise<import("@wxn0brp/db-core/types/arg").Arg>;
+    /**
+     * Find entries in the specified database based on search criteria.
+     */
+    find({ collection, search, context, dbFindOpts, findOpts }: VQuery): Promise<Data[]>;
+    /**
+     * Find the first matching entry in the specified database based on search criteria.
+     */
+    findOne({ collection, search, context, findOpts }: VQuery): Promise<Data>;
+    /**
+     * Update entries in the specified database based on search criteria and an updater function or object.
+     */
+    update({ collection, search, updater, context }: VQuery): Promise<boolean>;
+    /**
+     * Update the first matching entry in the specified database based on search criteria and an updater function or object.
+     */
+    updateOne({ collection, search, updater, context }: VQuery): Promise<boolean>;
+    /**
+     * Remove entries from the specified database based on search criteria.
+     */
+    remove({ collection, search, context }: VQuery): Promise<boolean>;
+    /**
+     * Remove the first matching entry from the specified database based on search criteria.
+     */
+    removeOne({ collection, search, context }: VQuery): Promise<boolean>;
+    /**
+     * Removes a database collection from the file system.
+     */
+    removeCollection({ collection }: {
+        collection: any;
+    }): Promise<boolean>;
+}
+export default dbActionC;

package/dist/action.js

@@ -0,0 +1,234 @@
+import dbActionBase from "@wxn0brp/db-core/base/actions";
+import gen from "@wxn0brp/db-core/helpers/gen";
+import { compareSafe } from "@wxn0brp/db-core/utils/sort";
+import { existsSync, mkdirSync, promises, statSync } from "fs";
+import { resolve, sep } from "path";
+/**
+ * A class representing database actions on files.
+ * @class
+ */
+class dbActionC extends dbActionBase {
+    folder;
+    options;
+    fileCpu;
+    /**
+     * Creates a new instance of dbActionC.
+     * @constructor
+     * @param folder - The folder where database files are stored.
+     * @param options - The options object.
+     */
+    constructor(folder, options, fileCpu) {
+        super();
+        this.folder = folder;
+        this.options = {
+            maxFileSize: 2 * 1024 * 1024, //2 MB
+            ...options,
+        };
+        this.fileCpu = fileCpu;
+        if (!existsSync(folder))
+            mkdirSync(folder, { recursive: true });
+    }
+    _getCollectionPath(collection) {
+        return this.folder + "/" + collection + "/";
+    }
+    /**
+     * Get a list of available databases in the specified folder.
+     */
+    async getCollections() {
+        const allCollections = await promises.readdir(this.folder, { recursive: true, withFileTypes: true });
+        const collections = allCollections
+            .filter(dirent => dirent.isDirectory())
+            .map(dirent => {
+            const parentPath = resolve(dirent.parentPath);
+            const baseFolder = resolve(this.folder);
+            if (parentPath === baseFolder)
+                return dirent.name;
+            return parentPath.replace(baseFolder + sep, "") + "/" + dirent.name;
+        });
+        return collections;
+    }
+    /**
+     * Check and create the specified collection if it doesn't exist.
+     */
+    async checkCollection({ collection }) {
+        if (await this.issetCollection(collection))
+            return;
+        const cpath = this._getCollectionPath(collection);
+        await promises.mkdir(cpath, { recursive: true });
+        return true;
+    }
+    /**
+     * Check if a collection exists.
+     */
+    async issetCollection({ collection }) {
+        const path = this._getCollectionPath(collection);
+        try {
+            await promises.access(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Add a new entry to the specified database.
+     */
+    async add({ collection, data, id_gen = true }) {
+        await this.checkCollection(arguments[0]);
+        const cpath = this._getCollectionPath(collection);
+        const file = cpath + await getLastFile(cpath, this.options.maxFileSize);
+        if (id_gen)
+            data._id = data._id || gen();
+        await this.fileCpu.add(file, data);
+        return data;
+    }
+    /**
+     * Find entries in the specified database based on search criteria.
+     */
+    async find({ collection, search, context = {}, dbFindOpts = {}, findOpts = {} }) {
+        const { reverse = false, max = -1, offset = 0, sortBy, sortAsc = true } = dbFindOpts;
+        await this.checkCollection(arguments[0]);
+        const cpath = this._getCollectionPath(collection);
+        let files = await getSortedFiles(cpath);
+        if (reverse && !sortBy)
+            files.reverse();
+        let datas = [];
+        let totalEntries = 0;
+        let skippedEntries = 0;
+        for (const f of files) {
+            let entries = await this.fileCpu.find(cpath + f, search, context, findOpts);
+            if (reverse && !sortBy)
+                entries.reverse();
+            if (!sortBy) {
+                if (offset > skippedEntries) {
+                    const remainingSkip = offset - skippedEntries;
+                    if (entries.length <= remainingSkip) {
+                        skippedEntries += entries.length;
+                        continue;
+                    }
+                    entries = entries.slice(remainingSkip);
+                    skippedEntries = offset;
+                }
+                if (max !== -1) {
+                    if (totalEntries + entries.length > max) {
+                        const remaining = max - totalEntries;
+                        entries = entries.slice(0, remaining);
+                        totalEntries = max;
+                    }
+                    else {
+                        totalEntries += entries.length;
+                    }
+                }
+                datas.push(...entries);
+                if (max !== -1 && totalEntries >= max)
+                    break;
+            }
+            else {
+                datas.push(...entries);
+            }
+        }
+        if (sortBy) {
+            const dir = sortAsc ? 1 : -1;
+            datas.sort((a, b) => compareSafe(a[sortBy], b[sortBy]) * dir);
+            const start = offset;
+            const end = max !== -1 ? offset + max : undefined;
+            datas = datas.slice(start, end);
+        }
+        return datas;
+    }
+    /**
+     * Find the first matching entry in the specified database based on search criteria.
+     */
+    async findOne({ collection, search, context = {}, findOpts = {} }) {
+        await this.checkCollection(arguments[0]);
+        const cpath = this._getCollectionPath(collection);
+        const files = await getSortedFiles(cpath);
+        for (let f of files) {
+            let data = await this.fileCpu.findOne(cpath + f, search, context, findOpts);
+            if (data)
+                return data;
+        }
+        return null;
+    }
+    /**
+     * Update entries in the specified database based on search criteria and an updater function or object.
+     */
+    async update({ collection, search, updater, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await operationUpdater(this._getCollectionPath(collection), this.fileCpu.update.bind(this.fileCpu), false, search, updater, context);
+    }
+    /**
+     * Update the first matching entry in the specified database based on search criteria and an updater function or object.
+     */
+    async updateOne({ collection, search, updater, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await operationUpdater(this._getCollectionPath(collection), this.fileCpu.update.bind(this.fileCpu), true, search, updater, context);
+    }
+    /**
+     * Remove entries from the specified database based on search criteria.
+     */
+    async remove({ collection, search, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await operationUpdater(this._getCollectionPath(collection), this.fileCpu.remove.bind(this.fileCpu), false, search, context);
+    }
+    /**
+     * Remove the first matching entry from the specified database based on search criteria.
+     */
+    async removeOne({ collection, search, context = {} }) {
+        await this.checkCollection(arguments[0]);
+        return await operationUpdater(this._getCollectionPath(collection), this.fileCpu.remove.bind(this.fileCpu), true, search, context);
+    }
+    /**
+     * Removes a database collection from the file system.
+     */
+    async removeCollection({ collection }) {
+        await promises.rm(this.folder + "/" + collection, { recursive: true, force: true });
+        return true;
+    }
+}
+/**
+ * Get the last file in the specified directory.
+ */
+async function getLastFile(path, maxFileSize = 1024 * 1024) {
+    if (!existsSync(path))
+        mkdirSync(path, { recursive: true });
+    const files = await getSortedFiles(path);
+    if (files.length == 0) {
+        await promises.writeFile(path + "/1.db", "");
+        return "1.db";
+    }
+    const last = files[files.length - 1];
+    const info = path + "/" + last;
+    if (statSync(info).size < maxFileSize)
+        return last;
+    const num = parseInt(last.replace(".db", ""), 10) + 1;
+    await promises.writeFile(path + "/" + num + ".db", "");
+    return num + ".db";
+}
+/**
+ * Get all files in a directory sorted by name.
+ */
+async function getSortedFiles(folder) {
+    const files = await promises.readdir(folder, { withFileTypes: true });
+    return files
+        .filter(file => file.isFile() && !file.name.endsWith(".tmp"))
+        .map(file => file.name)
+        .filter(name => /^\d+\.db$/.test(name))
+        .sort((a, b) => {
+        const numA = parseInt(a, 10);
+        const numB = parseInt(b, 10);
+        return numA - numB;
+    });
+}
+async function operationUpdater(cpath, worker, one, ...args) {
+    const files = await getSortedFiles(cpath);
+    let update = false;
+    for (const file of files) {
+        const updated = await worker(cpath + file, one, ...args);
+        update = update || updated;
+        if (one && updated)
+            break;
+    }
+    return update;
+}
+export default dbActionC;

package/dist/file/find.d.ts

@@ -0,0 +1,11 @@
+import { Search } from "@wxn0brp/db-core/types/arg";
+import { FindOpts } from "@wxn0brp/db-core/types/options";
+import { VContext } from "@wxn0brp/db-core/types/types";
+/**
+ * Asynchronously finds entries in a file based on search criteria.
+ */
+export declare function find(file: string, arg: Search, context?: VContext, findOpts?: FindOpts): Promise<any[] | false>;
+/**
+ * Asynchronously finds one entry in a file based on search criteria.
+ */
+export declare function findOne(file: string, arg: Search, context?: VContext, findOpts?: FindOpts): Promise<any | false>;

package/dist/file/find.js

@@ -0,0 +1,74 @@
+import hasFieldsAdvanced from "@wxn0brp/db-core/utils/hasFieldsAdvanced";
+import updateFindObject from "@wxn0brp/db-core/utils/updateFindObject";
+import { existsSync, promises } from "fs";
+import { createRL } from "./utils.js";
+import { parseData } from "../format.js";
+import { pathRepair } from "@wxn0brp/db-core/customFileCpu";
+/**
+ * Processes a line of text from a file and checks if it matches the search criteria.
+ */
+async function findProcesLine(arg, line, context = {}, findOpts = {}) {
+    const ob = parseData(line);
+    let res = false;
+    if (typeof arg === "function") {
+        if (arg(ob, context))
+            res = true;
+    }
+    else if (typeof arg === "object" && !Array.isArray(arg)) {
+        if (hasFieldsAdvanced(ob, arg))
+            res = true;
+    }
+    if (res)
+        return updateFindObject(ob, findOpts);
+    return null;
+}
+/**
+ * Asynchronously finds entries in a file based on search criteria.
+ */
+export async function find(file, arg, context = {}, findOpts = {}) {
+    file = pathRepair(file);
+    return await new Promise(async (resolve) => {
+        if (!existsSync(file)) {
+            await promises.writeFile(file, "");
+            resolve(false);
+            return;
+        }
+        const rl = createRL(file);
+        const resF = [];
+        for await (const line of rl) {
+            if (line == "" || !line)
+                continue;
+            const res = await findProcesLine(arg, line, context, findOpts);
+            if (res)
+                resF.push(res);
+        }
+        ;
+        resolve(resF);
+        rl.close();
+    });
+}
+/**
+ * Asynchronously finds one entry in a file based on search criteria.
+ */
+export async function findOne(file, arg, context = {}, findOpts = {}) {
+    file = pathRepair(file);
+    return await new Promise(async (resolve) => {
+        if (!existsSync(file)) {
+            await promises.writeFile(file, "");
+            resolve(false);
+            return;
+        }
+        const rl = createRL(file);
+        for await (const line of rl) {
+            if (line == "" || !line)
+                continue;
+            const res = await findProcesLine(arg, line, context, findOpts);
+            if (res) {
+                resolve(res);
+                rl.close();
+            }
+        }
+        ;
+        resolve(false);
+    });
+}

package/dist/file/index.d.ts

@@ -0,0 +1,3 @@
+import FileCpu from "@wxn0brp/db-core/types/fileCpu";
+declare const vFileCpu: FileCpu;
+export default vFileCpu;

package/dist/file/index.js

@@ -0,0 +1,16 @@
+import update from "./update.js";
+import remove from "./remove.js";
+import { find, findOne } from "./find.js";
+import { appendFileSync } from "fs";
+import { stringifyData } from "../format.js";
+const vFileCpu = {
+    add: async (file, data) => {
+        const dataString = stringifyData(data);
+        appendFileSync(file, dataString + "\n");
+    },
+    find,
+    findOne,
+    update,
+    remove,
+};
+export default vFileCpu;

package/dist/file/remove.d.ts

@@ -0,0 +1,7 @@
+import { Search } from "@wxn0brp/db-core/types/arg";
+import { VContext } from "@wxn0brp/db-core/types/types";
+/**
+ * Removes entries from a file based on search criteria.
+ */
+declare function removeWorker(file: string, one: boolean, search: Search, context?: VContext): Promise<boolean>;
+export default removeWorker;

package/dist/file/remove.js

@@ -0,0 +1,42 @@
+import { existsSync, promises, appendFileSync } from "fs";
+import { createRL } from "./utils.js";
+import hasFieldsAdvanced from "@wxn0brp/db-core/utils/hasFieldsAdvanced";
+import { parseData } from "../format.js";
+import { pathRepair } from "@wxn0brp/db-core/customFileCpu";
+/**
+ * Removes entries from a file based on search criteria.
+ */
+async function removeWorker(file, one, search, context = {}) {
+    file = pathRepair(file);
+    if (!existsSync(file)) {
+        await promises.writeFile(file, "");
+        return false;
+    }
+    await promises.copyFile(file, file + ".tmp");
+    await promises.writeFile(file, "");
+    const rl = createRL(file + ".tmp");
+    let removed = false;
+    for await (let line of rl) {
+        if (one && removed) {
+            appendFileSync(file, line + "\n");
+            continue;
+        }
+        const data = parseData(line);
+        if (typeof search === "function") {
+            if (search(data, context)) {
+                removed = true;
+                continue;
+            }
+        }
+        else if (typeof search === "object" && !Array.isArray(search)) {
+            if (hasFieldsAdvanced(data, search)) {
+                removed = true;
+                continue;
+            }
+        }
+        appendFileSync(file, line + "\n");
+    }
+    await promises.writeFile(file + ".tmp", "");
+    return removed;
+}
+export default removeWorker;

package/dist/file/update.d.ts

@@ -0,0 +1,7 @@
+import { Search, Updater } from "@wxn0brp/db-core/types/arg";
+import { VContext } from "@wxn0brp/db-core/types/types";
+/**
+ * Updates a file based on search criteria and an updater function or object.
+ */
+declare function updateWorker(file: string, one: boolean, search: Search, updater: Updater, context?: VContext): Promise<boolean>;
+export default updateWorker;

package/dist/file/update.js

@@ -0,0 +1,51 @@
+import { existsSync, promises } from "fs";
+import { createRL } from "./utils.js";
+import hasFieldsAdvanced from "@wxn0brp/db-core/utils/hasFieldsAdvanced";
+import updateObjectAdvanced from "@wxn0brp/db-core/utils/updateObject";
+import { parseData, stringifyData } from "../format.js";
+import { pathRepair } from "@wxn0brp/db-core/customFileCpu";
+/**
+ * Updates a file based on search criteria and an updater function or object.
+ */
+async function updateWorker(file, one, search, updater, context = {}) {
+    file = pathRepair(file);
+    if (!existsSync(file)) {
+        await promises.writeFile(file, "");
+        return false;
+    }
+    await promises.copyFile(file, file + ".tmp");
+    await promises.writeFile(file, "");
+    const rl = createRL(file + ".tmp");
+    let updated = false;
+    for await (let line of rl) {
+        if (one && updated) {
+            await promises.appendFile(file, line + "\n");
+            continue;
+        }
+        const data = parseData(line);
+        let ob = false;
+        if (typeof search === "function") {
+            ob = search(data, context) || false;
+        }
+        else if (typeof search === "object" && !Array.isArray(search)) {
+            ob = hasFieldsAdvanced(data, search);
+        }
+        if (ob) {
+            let updateObj = data;
+            if (typeof updater === "function") {
+                const updateObjValue = updater(data, context);
+                if (updateObjValue)
+                    updateObj = updateObjValue;
+            }
+            else if (typeof updater === "object" && !Array.isArray(updater)) {
+                updateObj = updateObjectAdvanced(data, updater);
+            }
+            line = await stringifyData(updateObj);
+            updated = true;
+        }
+        await promises.appendFile(file, line + "\n");
+    }
+    await promises.writeFile(file + ".tmp", "");
+    return updated;
+}
+export default updateWorker;

package/dist/file/utils.d.ts

@@ -0,0 +1,4 @@
+export interface LineReader extends AsyncIterable<string> {
+    close: () => void;
+}
+export declare function createRL(file: string): LineReader;

package/dist/file/utils.js

@@ -0,0 +1,78 @@
+import { createReadStream } from "fs";
+export function createRL(file) {
+    const stream = createReadStream(file, { highWaterMark: 64 * 1024 });
+    let buffer = "";
+    let done = false;
+    let error = null;
+    const lines = [];
+    let waiting = null;
+    stream.on("data", (chunk) => {
+        buffer += chunk.toString("utf8");
+        let index;
+        while ((index = buffer.search(/\r?\n/)) >= 0) {
+            const line = buffer.slice(0, index);
+            lines.push(line);
+            buffer = buffer.slice(index + (buffer[index] === "\r" && buffer[index + 1] === "\n" ? 2 : 1));
+        }
+        feed();
+    });
+    stream.on("end", () => {
+        if (buffer.length > 0) {
+            lines.push(buffer);
+            buffer = "";
+        }
+        done = true;
+        feed();
+    });
+    stream.on("error", (err) => {
+        error = err;
+        done = true;
+        feed();
+    });
+    const feed = () => {
+        if (waiting) {
+            if (error) {
+                waiting(Promise.reject(error));
+            }
+            else if (lines.length > 0) {
+                waiting({ value: lines.shift(), done: false });
+            }
+            else if (done) {
+                waiting({ value: undefined, done: true });
+            }
+            else {
+                return;
+            }
+            waiting = null;
+        }
+    };
+    const iterator = {
+        next() {
+            if (error)
+                return Promise.reject(error);
+            if (lines.length > 0)
+                return Promise.resolve({ value: lines.shift(), done: false });
+            if (done)
+                return Promise.resolve({ value: undefined, done: true });
+            return new Promise(res => {
+                waiting = res;
+            });
+        },
+        return() {
+            rl.close();
+            return Promise.resolve({ value: undefined, done: true });
+        }
+    };
+    const rl = {
+        [Symbol.asyncIterator]() {
+            return iterator;
+        },
+        close() {
+            if (!done) {
+                done = true;
+                stream.destroy();
+            }
+        }
+    };
+    return rl;
+}

package/dist/format.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parses given string into a JSON object. If the string does not start with
+ * a {, it is wrapped in one. This allows for a shorthand when
+ * storing/reading data from a file.
+ */
+export declare function parseData(data: string): any;
+/**
+ * Converts given object to a string. If the string is a valid json5, it is
+ * returned as is. If it is a valid json5 wrapped in {}, the curly brackets
+ * are removed. Otherwise the string is wrapped in {}.
+ */
+export declare function stringifyData(data: any): any;

package/dist/format.js

@@ -0,0 +1,23 @@
+import json5 from "json5";
+/**
+ * Parses given string into a JSON object. If the string does not start with
+ * a {, it is wrapped in one. This allows for a shorthand when
+ * storing/reading data from a file.
+ */
+export function parseData(data) {
+    if (!data.startsWith("{"))
+        data = "{" + data + "}";
+    return json5.parse(data);
+}
+/**
+ * Converts given object to a string. If the string is a valid json5, it is
+ * returned as is. If it is a valid json5 wrapped in {}, the curly brackets
+ * are removed. Otherwise the string is wrapped in {}.
+ */
+export function stringifyData(data) {
+    data = json5.stringify(data);
+    if (data.startsWith("{")) {
+        data = data.slice(1, -1);
+    }
+    return data;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./file/index.js";

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./file/index.js";

package/dist/version.js

@@ -0,0 +1 @@
+export const version = "0.0.1";

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@wxn0brp/db-storage-dir",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "wxn0brP",
+  "license": "MIT",
+  "type": "module",
+  "description": "ValtheraDB Dir Storage",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wxn0brP/ValtheraDB-storage-dir.git"
+  },
+  "homepage": "https://github.com/wxn0brP/ValtheraDB",
+  "dependencies": {
+    "json5": "^2.2.3",
+    "@wxn0brp/db-core": ">=0.0.1 <0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.12.0",
+    "tsc-alias": "^1.8.10",
+    "typescript": "^5.7.3"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "import": "./dist/*.js",
+      "default": "./dist/*.js"
+    }
+  }
+}