@based/db 0.0.52 → 0.0.56

package/dist/src/server/migrate/index.js

@@ -1,13 +1,12 @@
-import { BasedDb } from '../../index.js';
+import { BasedDb, save } from '../../index.js';
 import { dirname, join } from 'path';
-import { tmpdir } from 'os';
 import { Worker, MessageChannel, receiveMessageOnPort, } from 'node:worker_threads';
 import native from '../../native.js';
 import { destructureCsmtKey, foreachDirtyBlock, specialBlock } from '../tree.js';
-import { SCHEMA_FILE } from '../index.js';
 import { fileURLToPath } from 'url';
+import { setNativeSchema, setSchemaOnServer, writeSchemaFile, } from '../schema.js';
+import { setToAwake, waitUntilSleeping } from './utils.js';
 import { deepMerge } from '@saulx/utils';
-import { writeFile } from 'fs/promises';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const workerPath = join(__dirname, 'worker.js');
@@ -29,32 +28,33 @@ const parseTransform = (transform) => {
     }
     return res;
 };
-export const migrate = async (fromDbServer, toSchema, transform) => {
-    const migrationId = migrationCnt++;
-    fromDbServer.migrating = migrationId;
-    const abort = () => fromDbServer.migrating !== migrationId;
-    const toDb = new BasedDb({
-        path: join(tmpdir(), (~~(Math.random() * 1e9)).toString(36)),
+export const migrate = async (server, fromSchema, toSchema, transform) => {
+    const migrationId = toSchema.hash;
+    server.migrating = migrationId;
+    const abort = () => server.migrating !== migrationId;
+    const tmpDb = new BasedDb({
+        path: null,
     });
-    await toDb.start({ clean: true });
+    await tmpDb.start({ clean: true });
     if (abort()) {
-        await toDb.destroy();
-        return fromDbServer.schema;
+        await tmpDb.destroy();
+        return;
     }
-    toSchema = await toDb.setSchema(toSchema);
+    setSchemaOnServer(tmpDb.server, toSchema);
+    // await writeSchemaFile(this, toSchema)
+    await setNativeSchema(tmpDb.server, toSchema);
     if (abort()) {
-        await toDb.destroy();
-        return fromDbServer.schema;
+        await tmpDb.destroy();
+        return;
     }
-    const fromSchema = fromDbServer.schema;
-    const fromCtx = fromDbServer.dbCtxExternal;
-    const toCtx = toDb.server.dbCtxExternal;
+    const fromCtx = server.dbCtxExternal;
+    const toCtx = tmpDb.server.dbCtxExternal;
     const { port1, port2 } = new MessageChannel();
-    const atomics = new Int32Array(new SharedArrayBuffer(4));
+    const workerState = new Int32Array(new SharedArrayBuffer(4));
     const fromAddress = native.intFromExternal(fromCtx);
     const toAddress = native.intFromExternal(toCtx);
     const transformFns = parseTransform(transform);
-    atomics[0] = 1;
+    setToAwake(workerState, false);
     const worker = new Worker(workerPath, {
         workerData: {
             isDbMigrateWorker: true,
@@ -63,80 +63,85 @@ export const migrate = async (fromDbServer, toSchema, transform) => {
             fromSchema,
             toSchema,
             channel: port2,
-            atomics,
+            workerState,
             transformFns,
         },
         transferList: [port2],
     });
+    // handle?
     worker.on('error', console.error);
+    // Block handling
     let i = 0;
-    let ranges = [];
-    await fromDbServer.save();
-    fromDbServer.merkleTree.visitLeafNodes((leaf) => {
+    let rangesToMigrate = [];
+    await save(server, false, false, true);
+    server.merkleTree.visitLeafNodes((leaf) => {
         const [_typeId, start] = destructureCsmtKey(leaf.key);
         if (start == specialBlock)
             return; // skip the type specialBlock
-        ranges.push(leaf.data);
+        rangesToMigrate.push(leaf.data);
     });
-    await Atomics.waitAsync(atomics, 0, 1).value;
-    while (i < ranges.length) {
+    await waitUntilSleeping(workerState);
+    while (i < rangesToMigrate.length) {
         if (abort()) {
             break;
         }
         // block modifies
-        fromDbServer.processingQueries++;
-        const leafData = ranges[i++];
+        server.processingQueries++;
+        const leafData = rangesToMigrate[i++];
         port1.postMessage(leafData);
-        // wake up the worker
-        atomics[0] = 1;
-        Atomics.notify(atomics, 0);
-        // wait until it's done
-        await Atomics.waitAsync(atomics, 0, 1).value;
+        setToAwake(workerState, true);
+        await waitUntilSleeping(workerState);
         // exec queued modifies
-        fromDbServer.onQueryEnd();
-        if (i === ranges.length) {
-            if (fromDbServer.dirtyRanges.size) {
-                ranges = [];
+        server.onQueryEnd();
+        if (i === rangesToMigrate.length) {
+            if (server.dirtyRanges.size) {
+                rangesToMigrate = [];
                 i = 0;
-                foreachDirtyBlock(fromDbServer, (_mtKey, typeId, start, end) => {
-                    ranges.push({
+                foreachDirtyBlock(server, (_mtKey, typeId, start, end) => {
+                    rangesToMigrate.push({
                         typeId,
                         start,
                         end,
                     });
                 });
-                fromDbServer.dirtyRanges.clear();
+                server.dirtyRanges.clear();
             }
         }
     }
+    // ---------------------------------
     if (abort()) {
-        await Promise.all([toDb.destroy(), worker.terminate()]);
-        return fromDbServer.schema;
+        await Promise.all([tmpDb.destroy(), worker.terminate()]);
+        return;
     }
     let msg;
-    let schema;
     let schemaTypesParsed;
     while ((msg = receiveMessageOnPort(port1))) {
-        ;
-        [schema, schemaTypesParsed] = msg.message;
+        schemaTypesParsed = msg.message;
     }
-    fromDbServer.dbCtxExternal = toCtx;
-    fromDbServer.sortIndexes = {};
-    fromDbServer.schema = deepMerge(toDb.server.schema, schema);
-    fromDbServer.schemaTypesParsed = deepMerge(toDb.server.schemaTypesParsed, schemaTypesParsed);
-    fromDbServer.schemaTypesParsedById = {};
-    for (const key in fromDbServer.schemaTypesParsed) {
-        const def = fromDbServer.schemaTypesParsed[key];
-        fromDbServer.schemaTypesParsedById[def.id] = def;
+    server.dbCtxExternal = toCtx;
+    server.sortIndexes = {};
+    // ----------------MAKE NICE THIS------------------
+    // pass last node IDS { type: lastId }
+    setSchemaOnServer(server, toSchema);
+    // make schema util for this later
+    server.schemaTypesParsed = deepMerge(tmpDb.server.schemaTypesParsed, schemaTypesParsed);
+    server.schemaTypesParsedById = {};
+    for (const key in server.schemaTypesParsed) {
+        const def = server.schemaTypesParsed[key];
+        server.schemaTypesParsedById[def.id] = def;
     }
-    toDb.server.dbCtxExternal = fromCtx;
-    const promises = fromDbServer.workers.map((worker) => worker.updateCtx(toAddress));
-    promises.push(toDb.destroy(), worker.terminate(), fromDbServer.save({ forceFullDump: true }), writeFile(join(fromDbServer.fileSystemPath, SCHEMA_FILE), JSON.stringify(fromDbServer.schema)));
+    // -----------------------------------------
+    tmpDb.server.dbCtxExternal = fromCtx;
+    // TODO makes this SYNC
+    const promises = server.workers.map((worker) => worker.updateCtx(toAddress));
+    promises.push(tmpDb.destroy(), worker.terminate());
     await Promise.all(promises);
     if (abort()) {
-        return fromDbServer.schema;
+        return;
     }
-    fromDbServer.onSchemaChange?.(fromDbServer.schema);
-    return fromDbServer.schema;
+    await save(server, false, true, true);
+    await writeSchemaFile(server, toSchema);
+    server.migrating = 0;
+    process.nextTick(() => server.emit('schema', server.schema));
 };
 //# sourceMappingURL=index.js.map

package/dist/src/server/migrate/types.d.ts

@@ -0,0 +1,4 @@
+export declare enum MigrationState {
+    AWAKE = 1,
+    SLEEP = 0
+}

package/dist/src/server/migrate/types.js

@@ -0,0 +1,6 @@
+export var MigrationState;
+(function (MigrationState) {
+    MigrationState[MigrationState["AWAKE"] = 1] = "AWAKE";
+    MigrationState[MigrationState["SLEEP"] = 0] = "SLEEP";
+})(MigrationState || (MigrationState = {}));
+//# sourceMappingURL=types.js.map

package/dist/src/server/migrate/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const waitUntilSleeping: (workerState: Int32Array) => Promise<void>;
+export declare const setToAwake: (workerState: Int32Array, notify: boolean) => void;
+export declare const setToSleep: (workerState: Int32Array) => void;

package/dist/src/server/migrate/utils.js

@@ -0,0 +1,16 @@
+import { MigrationState } from './types.js';
+export const waitUntilSleeping = async (workerState) => {
+    await Atomics.waitAsync(workerState, 0, MigrationState.AWAKE).value;
+};
+export const setToAwake = (workerState, notify) => {
+    workerState[0] = MigrationState.AWAKE;
+    if (notify) {
+        Atomics.notify(workerState, 0);
+    }
+};
+export const setToSleep = (workerState) => {
+    workerState[0] = MigrationState.SLEEP;
+    Atomics.notify(workerState, 0);
+    Atomics.wait(workerState, 0, MigrationState.SLEEP);
+};
+//# sourceMappingURL=utils.js.map

package/dist/src/server/migrate/worker.js

@@ -3,16 +3,18 @@ import native from '../../native.js';
 import { BasedDb } from '../../index.js';
 import { REFERENCE, REFERENCES } from '@based/schema/def';
 import { isTypedArray } from 'node:util/types';
+import { setSchemaOnServer } from '../schema.js';
+import { setToSleep } from './utils.js';
+import { setLocalClientSchema } from '../../client/setLocalClientSchema.js';
 if (isMainThread) {
     console.warn('running worker.ts in mainthread');
 }
 else if (workerData?.isDbMigrateWorker) {
-    const { from, to, fromSchema, toSchema, channel, atomics, transformFns } = workerData;
+    const { from, to, fromSchema, toSchema, channel, workerState, transformFns } = workerData;
     const fromCtx = native.externalFromInt(from);
     const toCtx = native.externalFromInt(to);
-    const path = null;
-    const fromDb = new BasedDb({ path });
-    const toDb = new BasedDb({ path });
+    const fromDb = new BasedDb({ path: null });
+    const toDb = new BasedDb({ path: null });
     const cp = (obj) => {
         let copy;
         for (const key in obj) {
@@ -36,11 +38,13 @@ else if (workerData?.isDbMigrateWorker) {
     };
     fromDb.server.dbCtxExternal = fromCtx;
     toDb.server.dbCtxExternal = toCtx;
-    await fromDb.setSchema(fromSchema, true);
-    await toDb.setSchema(toSchema, true);
+    setSchemaOnServer(fromDb.server, fromSchema);
+    setSchemaOnServer(toDb.server, toSchema);
+    setLocalClientSchema(fromDb.client, fromDb.server.schema);
+    setLocalClientSchema(toDb.client, toDb.server.schema);
     const map = {};
-    for (const type in fromDb.client.schemaTypesParsed) {
-        const { id, props } = fromDb.client.schemaTypesParsed[type];
+    for (const type in fromDb.server.schemaTypesParsed) {
+        const { id, props } = fromDb.server.schemaTypesParsed[type];
         const include = Object.keys(props);
         let i = include.length;
         while (i--) {
@@ -77,7 +81,7 @@ else if (workerData?.isDbMigrateWorker) {
                 const nodes = fromDb
                     .query(type)
                     .include(include)
-                    .range(leafData.start - 1, leafData.end - 1)
+                    .range(leafData.start - 1, leafData.end)
                     ._getSync(fromCtx);
                 for (const node of nodes) {
                     const res = typeTransformFn(node);
@@ -92,11 +96,11 @@ else if (workerData?.isDbMigrateWorker) {
                     }
                 }
             }
-            else if (type in toDb.client.schemaTypesParsed) {
+            else if (type in toDb.server.schemaTypesParsed) {
                 const nodes = fromDb
                     .query(type)
                     .include(include)
-                    .range(leafData.start - 1, leafData.end - 1)
+                    .range(leafData.start - 1, leafData.end)
                     ._getSync(fromCtx);
                 for (const node of nodes) {
                     toDb.create(type, node, { unsafe: true });
@@ -104,14 +108,9 @@ else if (workerData?.isDbMigrateWorker) {
             }
         }
         await toDb.drain();
-        channel.postMessage([
-            cp(toDb.server.schema),
-            cp(toDb.server.schemaTypesParsed),
-        ]);
-        // put it to sleep
-        atomics[0] = 0;
-        Atomics.notify(atomics, 0);
-        Atomics.wait(atomics, 0, 0);
+        // WE ARE ONLY GOING TO SEND { type: lastNodeId }
+        channel.postMessage(cp(toDb.server.schemaTypesParsed));
+        setToSleep(workerState);
     }
 }
 else {

package/dist/src/server/resizeModifyDirtyRanges.d.ts

@@ -0,0 +1,2 @@
+import { DbServer } from './index.js';
+export declare const resizeModifyDirtyRanges: (server: DbServer) => void;

package/dist/src/server/resizeModifyDirtyRanges.js

@@ -0,0 +1,17 @@
+export const resizeModifyDirtyRanges = (server) => {
+    let maxNrChanges = 0;
+    for (const typeId in server.schemaTypesParsedById) {
+        const def = server.schemaTypesParsedById[typeId];
+        const lastId = def.lastId;
+        const blockCapacity = def.blockCapacity;
+        const tmp = lastId - +!(lastId % def.blockCapacity);
+        const lastBlock = Math.ceil((((tmp / blockCapacity) | 0) * blockCapacity + 1) / blockCapacity);
+        maxNrChanges += lastBlock;
+    }
+    if (!server.modifyDirtyRanges ||
+        server.modifyDirtyRanges.length < maxNrChanges) {
+        const min = Math.max(maxNrChanges * 1.2, 1024) | 0;
+        server.modifyDirtyRanges = new Float64Array(min);
+    }
+};
+//# sourceMappingURL=resizeModifyDirtyRanges.js.map

package/dist/src/server/save.d.ts

@@ -18,4 +18,4 @@ export type Writelog = {
         }[];
     };
 };
-export declare function save<T extends boolean>(db: DbServer, sync?: T, forceFullDump?: boolean): T extends true ? void : Promise<void>;
+export declare function save<T extends boolean>(db: DbServer, sync?: T, forceFullDump?: boolean, skipMigrationCheck?: boolean): T extends true ? void : Promise<void>;

package/dist/src/server/save.js

@@ -3,10 +3,9 @@ import { isMainThread } from 'node:worker_threads';
 import { writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { destructureCsmtKey, foreachBlock, foreachDirtyBlock, initCsmt, makeCsmtKey, specialBlock, } from './tree.js';
-import { WRITELOG_FILE } from './index.js';
 import { writeFileSync } from 'node:fs';
 import { bufToHex } from '@saulx/utils';
-const COMMON_SDB_FILE = 'common.sdb';
+import { COMMON_SDB_FILE, WRITELOG_FILE } from '../types.js';
 const block_sdb_file = (typeId, start, end) => `${typeId}_${start}_${end}.sdb`;
 function saveRange(db, typeId, start, end, hashOut) {
     const file = block_sdb_file(typeId, start, end);
@@ -23,10 +22,13 @@ function saveRange(db, typeId, start, end, hashOut) {
     }
     return file;
 }
-export function save(db, sync = false, forceFullDump = false) {
+export function save(db, sync = false, forceFullDump = false, skipMigrationCheck = false) {
     if (!(isMainThread && (db.dirtyRanges.size || forceFullDump))) {
         return;
     }
+    if (db.migrating && !skipMigrationCheck) {
+        return;
+    }
     let err;
     const ts = Date.now();
     err = native.saveCommon(join(db.fileSystemPath, COMMON_SDB_FILE), db.dbCtxExternal);

package/dist/src/server/schema.d.ts

@@ -0,0 +1,7 @@
+import { DbServer } from './index.js';
+import { DbSchema } from '../schema.js';
+import { StrictSchema } from '@based/schema';
+export declare const setSchemaOnServer: (server: DbServer, schema: DbSchema) => void;
+export declare const writeSchemaFile: (server: DbServer, schema: DbSchema) => Promise<void>;
+export declare const setNativeSchema: (server: DbServer, schema: DbSchema) => Promise<void>;
+export declare const strictSchemaToDbSchema: (schema: StrictSchema) => DbSchema;

package/dist/src/server/schema.js

@@ -0,0 +1,111 @@
+import { schemaToSelvaBuffer, updateTypeDefs } from '@based/schema/def';
+import { join } from 'node:path';
+import { writeFile } from 'node:fs/promises';
+import native from '../native.js';
+import { initCsmt, makeCsmtKey } from './tree.js';
+import { deepCopy, writeUint64 } from '@saulx/utils';
+import { SCHEMA_FILE } from '../types.js';
+import { hash } from '@saulx/hash';
+import { getPropType } from '@based/schema';
+export const setSchemaOnServer = (server, schema) => {
+    const { schemaTypesParsed, schemaTypesParsedById } = updateTypeDefs(schema);
+    server.schema = schema;
+    server.schemaTypesParsed = schemaTypesParsed;
+    server.schemaTypesParsedById = schemaTypesParsedById;
+};
+export const writeSchemaFile = async (server, schema) => {
+    const schemaFilePath = join(server.fileSystemPath, SCHEMA_FILE);
+    try {
+        await writeFile(schemaFilePath, JSON.stringify(schema));
+    }
+    catch (err) {
+        throw new Error(`Error writing schema to a file path ${schemaFilePath}}`);
+    }
+};
+export const setNativeSchema = async (server, schema) => {
+    const types = Object.keys(server.schemaTypesParsed);
+    const s = schemaToSelvaBuffer(server.schemaTypesParsed);
+    for (let i = 0; i < s.length; i++) {
+        const type = server.schemaTypesParsed[types[i]];
+        try {
+            native.updateSchemaType(type.id, new Uint8Array(s[i]), server.dbCtxExternal);
+        }
+        catch (err) {
+            throw new Error(`Cannot update schema on selva (native) ${type.type} ${err.message}`);
+        }
+    }
+    // Insert a root node
+    if (schema.types._root) {
+        // TODO fix server add it in schema at least
+        const data = [2, 1, 0, 0, 0, 1, 9, 1, 0, 0, 0, 7, 1, 0, 1];
+        const blockKey = makeCsmtKey(1, 1);
+        const buf = new Uint8Array(8 + data.length + 2 + 8 + 4);
+        const view = new DataView(buf.buffer, 0, buf.byteLength);
+        // set schema hash
+        writeUint64(buf, server.schema.hash, 0);
+        // add content
+        buf.set(data, 8);
+        // add typesLen
+        view.setFloat64(8 + data.length, 0, true);
+        // add dirty key
+        view.setFloat64(8 + data.length + 2, blockKey, true);
+        // add dataLen
+        view.setUint32(buf.length - 4, data.length, true);
+        server.modify(buf);
+        initCsmt(server);
+    }
+};
+export const strictSchemaToDbSchema = (schema) => {
+    // @ts-ignore
+    let dbSchema = deepCopy(schema);
+    // reserve 1 for root (even if you dont have it)
+    dbSchema.lastId = 1;
+    if (dbSchema.props) {
+        for (const key in dbSchema.props) {
+            const prop = dbSchema.props[key];
+            const propType = getPropType(prop);
+            let refProp;
+            if (propType === 'reference') {
+                refProp = prop;
+            }
+            else if (propType === 'references') {
+                refProp = prop.items;
+                prop.items = refProp;
+            }
+            if (refProp) {
+                const type = dbSchema.types[refProp.ref];
+                const inverseKey = '_' + key;
+                dbSchema.types[refProp.ref] = {
+                    ...type,
+                    props: {
+                        ...type.props,
+                        [inverseKey]: {
+                            items: {
+                                ref: '_root',
+                                prop: key,
+                            },
+                        },
+                    },
+                };
+                refProp.prop = inverseKey;
+            }
+        }
+        dbSchema.types ??= {};
+        // @ts-ignore This creates an internal type to use for root props
+        dbSchema.types._root = {
+            id: 1,
+            props: dbSchema.props,
+        };
+        delete dbSchema.props;
+    }
+    for (const field in dbSchema.types) {
+        if (!('id' in dbSchema.types[field])) {
+            dbSchema.lastId++;
+            dbSchema.types[field].id = dbSchema.lastId;
+        }
+    }
+    const { hash: _, ...rest } = dbSchema;
+    dbSchema.hash = hash(rest);
+    return dbSchema;
+};
+//# sourceMappingURL=schema.js.map

package/dist/src/server/start.js

@@ -1,13 +1,15 @@
-import { DbWorker, SCHEMA_FILE, WRITELOG_FILE } from './index.js';
+import { DbWorker } from './DbWorker.js';
 import native from '../native.js';
 import { rm, mkdir, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { destructureCsmtKey, foreachBlock, initCsmt, makeCsmtKey, specialBlock } from './tree.js';
+import { destructureCsmtKey, foreachBlock, initCsmt, makeCsmtKey, specialBlock, } from './tree.js';
 import { availableParallelism } from 'node:os';
 import exitHook from 'exit-hook';
 import { save } from './save.js';
 import { DEFAULT_BLOCK_CAPACITY } from '@based/schema/def';
 import { bufToHex } from '@saulx/utils';
+import { SCHEMA_FILE, WRITELOG_FILE } from '../types.js';
+import { setSchemaOnServer } from './schema.js';
 export async function start(db, opts) {
     const path = db.fileSystemPath;
     const noop = () => { };
@@ -45,7 +47,8 @@ export async function start(db, opts) {
         const schema = await readFile(join(path, SCHEMA_FILE));
         if (schema) {
             // Prop need to not call setting in selva
-            await db.setSchema(JSON.parse(schema.toString()), true);
+            setSchemaOnServer(db, JSON.parse(schema.toString()));
+            // setNativeSchema might still be nessecary...
         }
     }
     catch (err) {
@@ -91,7 +94,7 @@ export async function start(db, opts) {
                 return; // skip the type specialBlock
             newHashSet.add(bufToHex(hash));
         });
-        const setEq = (a, b) => a.size === b.size && [...a].every(value => b.has(value));
+        const setEq = (a, b) => a.size === b.size && [...a].every((value) => b.has(value));
         if (!setEq(oldHashSet, newHashSet)) {
             console.error(`WARN: CSMT hash mismatch.`);
         }
@@ -122,5 +125,8 @@ export async function start(db, opts) {
             save(db);
         }, db.saveIntervalInSeconds * 1e3);
     }
+    if (db.schema) {
+        db.emit('schema', db.schema);
+    }
 }
 //# sourceMappingURL=start.js.map

package/dist/src/shared/DbBase.d.ts

@@ -0,0 +1,13 @@
+import { SchemaTypeDef } from '@based/schema/def';
+import { DbSchema } from '../schema.js';
+import { Emitter } from './Emitter.js';
+export type EventMap = {
+    schema: DbSchema;
+};
+export type Event = keyof EventMap;
+export type Listener<T> = (data: T) => void;
+export declare class DbShared extends Emitter {
+    schema?: DbSchema;
+    schemaTypesParsed?: Record<string, SchemaTypeDef>;
+    schemaTypesParsedById?: Record<number, SchemaTypeDef>;
+}

package/dist/src/shared/DbBase.js

@@ -0,0 +1,7 @@
+import { Emitter } from './Emitter.js';
+export class DbShared extends Emitter {
+    schema;
+    schemaTypesParsed = {};
+    schemaTypesParsedById = {};
+}
+//# sourceMappingURL=DbBase.js.map

package/dist/src/shared/Emitter.d.ts

@@ -0,0 +1,17 @@
+import { DbSchema } from '../schema.js';
+export type EventMap = {
+    schema: DbSchema;
+};
+export type Event = keyof EventMap;
+export type Listener<T> = (data: T) => void;
+export declare class Emitter {
+    listeners: {
+        [E in Event]?: Listener<EventMap[E]>[];
+    };
+    emit<E extends Event>(type: E, val: EventMap[E]): void;
+    on<E extends Event>(type: E, fn: Listener<EventMap[E]>): void;
+    removeAllListeners(): void;
+    once<E extends Event>(type: E): Promise<EventMap[E]>;
+    once<E extends Event>(type: E, fn: Listener<EventMap[E]>): void;
+    off<E extends Event>(type: E, fn?: Listener<EventMap[E]>): void;
+}

package/dist/src/shared/Emitter.js

@@ -0,0 +1,66 @@
+export class Emitter {
+    listeners = {};
+    emit(type, val) {
+        if (this.listeners[type]) {
+            const lis = this.listeners[type];
+            for (let i = 0, len = lis.length; i < lis.length; i++) {
+                const fn = lis[i];
+                // @ts-ignore
+                fn(val);
+                if (len > lis.length) {
+                    if (lis[i] !== fn) {
+                        i--;
+                        len = lis.length;
+                    }
+                }
+            }
+        }
+    }
+    on(type, fn) {
+        if (!this.listeners[type]) {
+            this.listeners[type] = [];
+        }
+        this.listeners[type].push(fn);
+    }
+    removeAllListeners() {
+        this.listeners = {};
+    }
+    once(type, fn) {
+        if (!fn) {
+            return new Promise((resolve) => {
+                const listener = (v) => {
+                    resolve(v);
+                    this.off(type, listener);
+                };
+                this.on(type, listener);
+            });
+        }
+        // TODO: optmize this
+        const listener = () => {
+            this.off(type, listener);
+            this.off(type, fn);
+        };
+        this.on(type, fn);
+        this.on(type, listener);
+    }
+    off(type, fn) {
+        const listeners = this.listeners[type];
+        if (listeners) {
+            if (!fn) {
+                delete this.listeners[type];
+            }
+            else {
+                for (let i = 0; i < listeners.length; i++) {
+                    if (listeners[i] === fn) {
+                        listeners.splice(i, 1);
+                        break;
+                    }
+                }
+                if (listeners.length === 0) {
+                    delete this.listeners[type];
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=Emitter.js.map

package/dist/src/types.d.ts

@@ -0,0 +1,3 @@
+export declare const SCHEMA_FILE = "schema.json";
+export declare const WRITELOG_FILE = "writelog.json";
+export declare const COMMON_SDB_FILE = "common.sdb";

package/dist/src/types.js

@@ -0,0 +1,4 @@
+export const SCHEMA_FILE = 'schema.json';
+export const WRITELOG_FILE = 'writelog.json';
+export const COMMON_SDB_FILE = 'common.sdb';
+//# sourceMappingURL=types.js.map