@proto-kit/common 0.1.1-develop.1086

package/dist/config/ModuleContainer.js

@@ -0,0 +1,278 @@
+import "reflect-metadata";
+import { instancePerContainerCachingFactory, isClassProvider, isFactoryProvider, isTokenProvider, isValueProvider, Lifecycle, } from "tsyringe";
+import log from "loglevel";
+import merge from "lodash/merge";
+import { EventEmitterProxy } from "../events/EventEmitterProxy";
+import { ConfigurableModule, } from "./ConfigurableModule";
+const errors = {
+    configNotSetInContainer: (moduleName) => new Error(`Trying to get config of ${moduleName}, but it was not yet set in the module container`),
+    onlyValidModuleNames: (moduleName) => new Error(
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
+    `Only known module names are allowed, using unknown module name: ${moduleName}`),
+    unableToDecorateModule: (moduleName) => 
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
+    new Error(`Unable to decorate module ${moduleName.toString()}`),
+    nonModuleDependency: (runtimeModuleName) => new Error(`
+  Unable to register module: ${runtimeModuleName}, attempting to inject a non-module dependency`),
+    unknownDependency: (runtimeModuleName, name) => new Error(`Unable to register module: ${runtimeModuleName}, 
+      attempting to inject a dependency that is not registered 
+      as a runtime module for this chain: ${name}`),
+    dependencyContainerNotSet: (className) => new Error(`DependencyContainer not set. Be sure to only call DI-related function in create() and not inside the constructor. (${className})`),
+    validModuleInstance: (moduleName, moduleTypeName) => new Error(`Incompatible module instance ("${moduleName}" not instanceof ${moduleTypeName})`),
+};
+export const ModuleContainerErrors = errors;
+/**
+ * Reusable module container facilitating registration, resolution
+ * configuration, decoration and validation of modules
+ */
+export class ModuleContainer extends ConfigurableModule {
+    constructor(definition) {
+        super();
+        this.definition = definition;
+        // DI container holding all the registered modules
+        this.providedContainer = undefined;
+        this.eventEmitterProxy = undefined;
+    }
+    /**
+     * @returns list of module names
+     */
+    get moduleNames() {
+        return Object.keys(this.definition.modules);
+    }
+    /**
+     * Check if the provided module satisfies the container requirements,
+     * such as only injecting other known modules.
+     *
+     * @param moduleName
+     * @param containedModule
+     */
+    validateModule(moduleName, containedModule) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const dependencies = Reflect.getMetadata("design:paramtypes", containedModule);
+        dependencies?.forEach((dependency) => {
+            const name = typeof dependency === "string" ? dependency : dependency.name;
+            if (name === undefined) {
+                throw errors.nonModuleDependency(moduleName);
+            }
+            if (!this.moduleNames.includes(name)) {
+                throw errors.unknownDependency(moduleName, name);
+            }
+        });
+    }
+    get container() {
+        this.assertContainerInitialized(this.providedContainer);
+        return this.providedContainer;
+    }
+    /**
+     * Assert that the iterated `moduleName` is of ModuleName type,
+     * otherwise it may be just string e.g. when modules are iterated over
+     * using e.g. a for loop.
+     */
+    assertIsValidModuleName(moduleName) {
+        if (!this.isValidModuleName(this.definition.modules, moduleName)) {
+            throw errors.onlyValidModuleNames(moduleName);
+        }
+    }
+    isValidModuleName(modules, moduleName) {
+        return Object.prototype.hasOwnProperty.call(modules, moduleName);
+    }
+    assertContainerInitialized(container) {
+        if (container === undefined) {
+            throw errors.dependencyContainerNotSet(this.constructor.name);
+        }
+    }
+    /**
+     * Register modules into the current container, and registers
+     * a respective resolution hook in order to decorate the module
+     * upon/after resolution.
+     *
+     * @param modules
+     */
+    registerModules(modules) {
+        Object.keys(modules).forEach((moduleName) => {
+            if (Object.prototype.hasOwnProperty.call(modules, moduleName)) {
+                this.assertIsValidModuleName(moduleName);
+                log.debug(`Registering module: ${moduleName}`);
+                const useClass = modules[moduleName];
+                this.container.register(moduleName, { useClass }, { lifecycle: Lifecycle.ContainerScoped });
+                this.onAfterModuleResolution(moduleName);
+            }
+        });
+    }
+    get events() {
+        if (this.eventEmitterProxy === undefined) {
+            this.eventEmitterProxy = new EventEmitterProxy(this);
+        }
+        return this.eventEmitterProxy;
+    }
+    /**
+     * Register a non-module value into the current container
+     * @param modules
+     */
+    // TODO Rename to plural since object is param
+    registerValue(modules) {
+        Object.entries(modules).forEach(([moduleName, useValue]) => {
+            this.container.register(moduleName, { useValue });
+        });
+    }
+    registerClasses(modules) {
+        Object.entries(modules).forEach(([moduleName, useClass]) => {
+            this.container.register(moduleName, { useClass }, { lifecycle: Lifecycle.ContainerScoped });
+        });
+    }
+    /**
+     * Provide additional configuration after the ModuleContainer was created.
+     *
+     * Keep in mind that modules are only decorated once after they are resolved,
+     * therefore applying any configuration must happen
+     * before the first resolution.
+     * @param config
+     */
+    configure(config) {
+        this.config = config;
+    }
+    configurePartial(config) {
+        this.config = merge(this.currentConfig ?? {}, config);
+    }
+    get config() {
+        return super.config;
+    }
+    set config(config) {
+        super.config = merge(this.currentConfig ?? {}, config);
+    }
+    /**
+     * Resolves a module from the current module container
+     *
+     * We have to narrow down the `ModuleName` type here to
+     * `ResolvableModuleName`, otherwise the resolved value might
+     * be any module instance, not the one specifically requested as argument.
+     *
+     * @param moduleName
+     * @returns
+     */
+    resolve(moduleName) {
+        return this.container.resolve(moduleName);
+    }
+    resolveOrFail(moduleName, moduleType) {
+        const instance = this.container.resolve(moduleName);
+        const isValidModuleInstance = instance instanceof moduleType;
+        if (!isValidModuleInstance) {
+            throw errors.validModuleInstance(moduleName, moduleType.name);
+        }
+        return instance;
+    }
+    /**
+     * Override this in the child class to provide custom
+     * features or module checks
+     */
+    decorateModule(moduleName, containedModule) {
+        const config = super.config?.[moduleName];
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        if (!config) {
+            throw errors.configNotSetInContainer(moduleName.toString());
+        }
+        if (containedModule instanceof ModuleContainer) {
+            containedModule.configure(config);
+        }
+        else {
+            containedModule.config = config;
+        }
+    }
+    isDependencyFactory(type) {
+        return "dependencies" in type;
+    }
+    /**
+     * Inject a set of dependencies using the given list of DependencyFactories
+     * This method should be called during startup
+     */
+    initializeDependencyFactories(factories) {
+        factories.forEach((factoryName) => {
+            this.resolve(factoryName);
+        });
+    }
+    /**
+     * Retrieves all dependencies generated by a particular dependencyfactory
+     * and injects them inside this modulecontainer's DI container.
+     * This will be automatically called for every module, but can also be called
+     * explicitly to initialize an extra factory
+     * @param factory
+     * @private
+     */
+    useDependencyFactory(factory) {
+        const dependencies = factory.dependencies();
+        Object.entries(dependencies).forEach(([rawKey, declaration]) => {
+            const key = rawKey.charAt(0).toUpperCase() + rawKey.slice(1);
+            if (!this.container.isRegistered(key) ||
+                declaration.forceOverwrite === true) {
+                // Find correct provider type and call respective register
+                if (isValueProvider(declaration)) {
+                    this.container.register(key, declaration);
+                }
+                else if (isFactoryProvider(declaration)) {
+                    // this enables us to have a singletoned factory
+                    // that returns the same instance for each resolve
+                    this.container.register(key, {
+                        useFactory: instancePerContainerCachingFactory(declaration.useFactory),
+                    });
+                }
+                else if (isClassProvider(declaration)) {
+                    this.container.register(key, declaration, {
+                        lifecycle: Lifecycle.Singleton,
+                    });
+                    // eslint-disable-next-line sonarjs/no-duplicated-branches
+                }
+                else if (isTokenProvider(declaration)) {
+                    this.container.register(key, declaration, {
+                        lifecycle: Lifecycle.Singleton,
+                    });
+                }
+                else {
+                    // Can never be reached
+                    throw new Error("Above if-statement is exhaustive");
+                }
+            }
+            else {
+                log.debug(`Dependency ${key} already registered, skipping`);
+            }
+        });
+    }
+    /**
+     * Handle module resolution, e.g. by decorating resolved modules
+     * @param moduleName
+     */
+    onAfterModuleResolution(moduleName) {
+        this.container.afterResolution(moduleName, (containedModuleName, containedModule) => {
+            // special case where tsyringe may return multiple known instances (?)
+            if (Array.isArray(containedModule)) {
+                throw errors.unableToDecorateModule(containedModuleName);
+            }
+            this.decorateModule(moduleName, containedModule);
+            containedModule.create(() => {
+                const container = this.container.createChildContainer();
+                container.reset();
+                return container;
+            });
+            if (this.isDependencyFactory(containedModule)) {
+                this.useDependencyFactory(containedModule);
+            }
+        }, { frequency: ModuleContainer.moduleDecorationFrequency });
+    }
+    /**
+     * This is a placeholder for individual modules to override.
+     * This method will be called whenever the underlying container fully
+     * initialized
+     */
+    create(childContainerProvider) {
+        this.providedContainer = childContainerProvider();
+        this.registerValue({
+            ChildContainerProvider: () => this.container.createChildContainer(),
+        });
+        // register all provided modules when the container is created
+        this.registerModules(this.definition.modules);
+    }
+}
+/**
+ * Determines how often are modules decorated upon resolution
+ * from the tsyringe DI container
+ */
+ModuleContainer.moduleDecorationFrequency = "Once";

package/dist/dependencyFactory/DependencyFactory.d.ts

@@ -0,0 +1,29 @@
+import { ClassProvider, FactoryProvider, TokenProvider, ValueProvider } from "tsyringe";
+import { TypedClass } from "../types";
+import type { BaseModuleInstanceType } from "../config/ModuleContainer";
+export type DependencyDeclaration<Dependency> = ClassProvider<Dependency> | FactoryProvider<Dependency> | TokenProvider<Dependency> | ValueProvider<Dependency>;
+export type DependencyRecord = Record<string, DependencyDeclaration<unknown> & {
+    forceOverwrite?: boolean;
+}>;
+/**
+ * This is an abstract class for creating DependencyFactories, a pattern
+ * to bundle multiple smaller services into one and register them into the
+ * injection context.
+ *
+ * This can for example be a StorageDependencyFactory that creates dependencies
+ * like StateService, MerkleWitnessService, etc. So in general, services that
+ * are not ConfigurableModules, but still are their own logical unit.
+ *
+ * DependencyFactories are designed to only be used statically for sets of
+ * deps that are necessary for the sequencer to work.
+ */
+export interface DependencyFactory {
+    dependencies: () => DependencyRecord;
+}
+export type TypeFromDependencyDeclaration<Declaration extends DependencyDeclaration<unknown>> = Declaration extends DependencyDeclaration<infer Dependency> ? Dependency : never;
+export type CapitalizeAny<Key extends string | number | symbol> = Key extends string ? Capitalize<Key> : Key;
+export type MapDependencyRecordToTypes<Record extends DependencyRecord> = {
+    [Key in keyof Record as CapitalizeAny<Key>]: TypedClass<TypeFromDependencyDeclaration<Record[Key]>>;
+};
+export type InferDependencies<Class extends BaseModuleInstanceType> = Class extends DependencyFactory ? MapDependencyRecordToTypes<ReturnType<Class["dependencies"]>> : never;
+//# sourceMappingURL=DependencyFactory.d.ts.map

package/dist/dependencyFactory/DependencyFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DependencyFactory.d.ts","sourceRoot":"","sources":["../../src/dependencyFactory/DependencyFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EACf,aAAa,EACb,aAAa,EACd,MAAM,UAAU,CAAC;AAElB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAExE,MAAM,MAAM,qBAAqB,CAAC,UAAU,IACxC,aAAa,CAAC,UAAU,CAAC,GACzB,eAAe,CAAC,UAAU,CAAC,GAC3B,aAAa,CAAC,UAAU,CAAC,GACzB,aAAa,CAAC,UAAU,CAAC,CAAC;AAE9B,MAAM,MAAM,gBAAgB,GAAG,MAAM,CACnC,MAAM,EACN,qBAAqB,CAAC,OAAO,CAAC,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,CAC9D,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IAChC,YAAY,EAAE,MAAM,gBAAgB,CAAC;CACtC;AAED,MAAM,MAAM,6BAA6B,CACvC,WAAW,SAAS,qBAAqB,CAAC,OAAO,CAAC,IAElD,WAAW,SAAS,qBAAqB,CAAC,MAAM,UAAU,CAAC,GACvD,UAAU,GACV,KAAK,CAAC;AAEZ,MAAM,MAAM,aAAa,CAAC,GAAG,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,IAC5D,GAAG,SAAS,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;AAE7C,MAAM,MAAM,0BAA0B,CAAC,MAAM,SAAS,gBAAgB,IAAI;KACvE,GAAG,IAAI,MAAM,MAAM,IAAI,aAAa,CAAC,GAAG,CAAC,GAAG,UAAU,CACrD,6BAA6B,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAC3C;CACF,CAAC;AAEF,MAAM,MAAM,iBAAiB,CAAC,KAAK,SAAS,sBAAsB,IAChE,KAAK,SAAS,iBAAiB,GAC3B,0BAA0B,CAAC,UAAU,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC,GAC7D,KAAK,CAAC"}

package/dist/dependencyFactory/DependencyFactory.js

@@ -0,0 +1 @@
+export {};

package/dist/dependencyFactory/injectOptional.d.ts

@@ -0,0 +1,16 @@
+/**
+ * This function injects a dependency only if it has been registered, otherwise
+ * injects undefined. This can be useful for having optional dependencies, where
+ * tsyringe would normally error out and not be able to resolve. With this
+ * decorator, we can now do this.
+ *
+ * The strategy we employ here is that we inject a dummy into the global
+ * container that is of type UndefinedDisguise. We can't inject undefined
+ * directly, therefore we use this object to disguise itself as undefined.
+ * Then a child container registers something under the same token, it by
+ * default resolves that new dependency. If that doesn't happen, the
+ * resolution hits our disguise, which we then convert into undefined
+ * using the Transform
+ */
+export declare function injectOptional<T>(token: string): (target: any, propertyKey: string | symbol | undefined, parameterIndex: number) => any;
+//# sourceMappingURL=injectOptional.d.ts.map

package/dist/dependencyFactory/injectOptional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectOptional.d.ts","sourceRoot":"","sources":["../../src/dependencyFactory/injectOptional.ts"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,0FAG9C"}

package/dist/dependencyFactory/injectOptional.js

@@ -0,0 +1,39 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { container, injectable, injectWithTransform, Lifecycle, scoped, } from "tsyringe";
+let UndefinedDisguise = class UndefinedDisguise {
+};
+UndefinedDisguise = __decorate([
+    injectable(),
+    scoped(Lifecycle.ResolutionScoped)
+], UndefinedDisguise);
+class UndefinedTransform {
+    transform(incoming) {
+        if (incoming instanceof UndefinedDisguise) {
+            return undefined;
+        }
+        return incoming;
+    }
+}
+/**
+ * This function injects a dependency only if it has been registered, otherwise
+ * injects undefined. This can be useful for having optional dependencies, where
+ * tsyringe would normally error out and not be able to resolve. With this
+ * decorator, we can now do this.
+ *
+ * The strategy we employ here is that we inject a dummy into the global
+ * container that is of type UndefinedDisguise. We can't inject undefined
+ * directly, therefore we use this object to disguise itself as undefined.
+ * Then a child container registers something under the same token, it by
+ * default resolves that new dependency. If that doesn't happen, the
+ * resolution hits our disguise, which we then convert into undefined
+ * using the Transform
+ */
+export function injectOptional(token) {
+    container.register(token, { useClass: UndefinedDisguise });
+    return injectWithTransform(token, (UndefinedTransform));
+}

package/dist/events/EventEmitter.d.ts

@@ -0,0 +1,19 @@
+import { EventsRecord } from "./EventEmittingComponent";
+type ListenersHolder<Events extends EventsRecord> = {
+    [key in keyof Events]?: ((...args: Events[key]) => void)[];
+};
+export declare class EventEmitter<Events extends EventsRecord> {
+    protected readonly listeners: ListenersHolder<Events>;
+    protected readonly wildcardListeners: ((event: keyof Events, args: Events[keyof Events]) => void)[];
+    emit<Key extends keyof Events>(event: Key, ...parameters: Events[Key]): void;
+    onAll(listener: (event: keyof Events, args: unknown[]) => void): void;
+    on<Key extends keyof Events>(event: Key, listener: (...args: Events[Key]) => void): void;
+    /**
+     * Primitive .off() with identity comparison for now.
+     * Could be replaced by returning an id in .on() and using that.
+     */
+    off<Key extends keyof Events>(event: Key, listener: (...args: Events[Key]) => void): void;
+}
+export type EventListenable<Events extends EventsRecord> = Pick<EventEmitter<Events>, "on" | "onAll" | "off">;
+export {};
+//# sourceMappingURL=EventEmitter.d.ts.map

package/dist/events/EventEmitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventEmitter.d.ts","sourceRoot":"","sources":["../../src/events/EventEmitter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,KAAK,eAAe,CAAC,MAAM,SAAS,YAAY,IAAI;KACjD,GAAG,IAAI,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,EAAE;CAC3D,CAAC;AAEF,qBAAa,YAAY,CAAC,MAAM,SAAS,YAAY;IACnD,SAAS,CAAC,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC,MAAM,CAAC,CAAM;IAE3D,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAE,CAAC,CACrC,KAAK,EAAE,MAAM,MAAM,EACnB,IAAI,EAAE,MAAM,CAAC,MAAM,MAAM,CAAC,KACvB,IAAI,CAAC,EAAE,CAAM;IAEX,IAAI,CAAC,GAAG,SAAS,MAAM,MAAM,EAClC,KAAK,EAAE,GAAG,EACV,GAAG,UAAU,EAAE,MAAM,CAAC,GAAG,CAAC;IAarB,KAAK,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI;IAIrE,EAAE,CAAC,GAAG,SAAS,MAAM,MAAM,EAChC,KAAK,EAAE,GAAG,EACV,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,IAAI;IAK1C;;;OAGG;IACI,GAAG,CAAC,GAAG,SAAS,MAAM,MAAM,EACjC,KAAK,EAAE,GAAG,EACV,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,KAAK,IAAI;CAS3C;AAED,MAAM,MAAM,eAAe,CAAC,MAAM,SAAS,YAAY,IAAI,IAAI,CAC7D,YAAY,CAAC,MAAM,CAAC,EACpB,IAAI,GAAG,OAAO,GAAG,KAAK,CACvB,CAAC"}

package/dist/events/EventEmitter.js

@@ -0,0 +1,34 @@
+export class EventEmitter {
+    constructor() {
+        this.listeners = {};
+        this.wildcardListeners = [];
+    }
+    emit(event, ...parameters) {
+        const listeners = this.listeners[event];
+        if (listeners !== undefined) {
+            listeners.forEach((listener) => {
+                listener(...parameters);
+            });
+        }
+        this.wildcardListeners.forEach((wildcardListener) => {
+            wildcardListener(event, parameters);
+        });
+    }
+    onAll(listener) {
+        this.wildcardListeners.push(listener);
+    }
+    on(event, listener) {
+        var _a;
+        ((_a = this.listeners)[event] ?? (_a[event] = [])).push(listener);
+    }
+    /**
+     * Primitive .off() with identity comparison for now.
+     * Could be replaced by returning an id in .on() and using that.
+     */
+    off(event, listener) {
+        const events = this.listeners[event];
+        if (events !== undefined) {
+            this.listeners[event] = events.filter((candidate) => candidate !== listener);
+        }
+    }
+}

package/dist/events/EventEmitterProxy.d.ts

@@ -0,0 +1,17 @@
+import type { BaseModuleType, ModuleContainer, ModulesRecord } from "../config/ModuleContainer";
+import { StringKeyOf, UnionToIntersection } from "../types";
+import { EventEmitter } from "./EventEmitter";
+import { EventEmittingComponent, EventsRecord } from "./EventEmittingComponent";
+export type CastToEventsRecord<Record> = Record extends EventsRecord ? Record : {};
+export type ModuleEvents<ModuleType extends BaseModuleType> = InstanceType<ModuleType> extends EventEmittingComponent<infer Events> ? Events : InstanceType<ModuleType> extends ModuleContainer<infer NestedModules> ? CastToEventsRecord<ContainerEvents<NestedModules>> : EventsRecord;
+export type ContainerEvents<Modules extends ModulesRecord> = {
+    [Key in StringKeyOf<Modules>]: ModuleEvents<Modules[Key]>;
+};
+export type FlattenObject<Target extends Record<string, EventsRecord>> = UnionToIntersection<Target[keyof Target]>;
+export type FlattenedContainerEvents<Modules extends ModulesRecord> = FlattenObject<ContainerEvents<Modules>>;
+export declare class EventEmitterProxy<Modules extends ModulesRecord> extends EventEmitter<CastToEventsRecord<FlattenedContainerEvents<Modules>>> {
+    private readonly container;
+    constructor(container: ModuleContainer<Modules>);
+    private isEventEmitter;
+}
+//# sourceMappingURL=EventEmitterProxy.d.ts.map

package/dist/events/EventEmitterProxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventEmitterProxy.d.ts","sourceRoot":"","sources":["../../src/events/EventEmitterProxy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,aAAa,EACd,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE5D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAEhF,MAAM,MAAM,kBAAkB,CAAC,MAAM,IAAI,MAAM,SAAS,YAAY,GAChE,MAAM,GACN,EAAE,CAAC;AAEP,MAAM,MAAM,YAAY,CAAC,UAAU,SAAS,cAAc,IACxD,YAAY,CAAC,UAAU,CAAC,SAAS,sBAAsB,CAAC,MAAM,MAAM,CAAC,GACjE,MAAM,GACN,YAAY,CAAC,UAAU,CAAC,SAAS,eAAe,CAAC,MAAM,aAAa,CAAC,GACnE,kBAAkB,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,GAClD,YAAY,CAAC;AAErB,MAAM,MAAM,eAAe,CAAC,OAAO,SAAS,aAAa,IAAI;KAC1D,GAAG,IAAI,WAAW,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;CAC1D,CAAC;AAEF,MAAM,MAAM,aAAa,CAAC,MAAM,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,IACnE,mBAAmB,CAAC,MAAM,CAAC,MAAM,MAAM,CAAC,CAAC,CAAC;AAE5C,MAAM,MAAM,wBAAwB,CAAC,OAAO,SAAS,aAAa,IAChE,aAAa,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;AAE1C,qBAAa,iBAAiB,CAC5B,OAAO,SAAS,aAAa,CAC7B,SAAQ,YAAY,CAAC,kBAAkB,CAAC,wBAAwB,CAAC,OAAO,CAAC,CAAC,CAAC;IACxD,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,eAAe,CAAC,OAAO,CAAC;IAiBvE,OAAO,CAAC,cAAc;CAOvB"}

package/dist/events/EventEmitterProxy.js

@@ -0,0 +1,23 @@
+import { EventEmitter } from "./EventEmitter";
+export class EventEmitterProxy extends EventEmitter {
+    constructor(container) {
+        super();
+        this.container = container;
+        container.moduleNames.forEach((moduleName) => {
+            if (container.isValidModuleName(container.definition.modules, moduleName)) {
+                const module = container.resolve(moduleName);
+                if (this.isEventEmitter(module)) {
+                    module.events.onAll((events, args) => {
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                        this.emit(events, ...args);
+                    });
+                }
+            }
+        });
+    }
+    isEventEmitter(module) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const emitter = module.events;
+        return emitter !== undefined && emitter instanceof EventEmitter;
+    }
+}

package/dist/events/EventEmittingComponent.d.ts

@@ -0,0 +1,6 @@
+import type { EventEmitter } from "./EventEmitter";
+export type EventsRecord = Record<string, unknown[]>;
+export interface EventEmittingComponent<Events extends EventsRecord> {
+    events: EventEmitter<Events>;
+}
+//# sourceMappingURL=EventEmittingComponent.d.ts.map

package/dist/events/EventEmittingComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventEmittingComponent.d.ts","sourceRoot":"","sources":["../../src/events/EventEmittingComponent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;AAErD,MAAM,WAAW,sBAAsB,CAAC,MAAM,SAAS,YAAY;IACjE,MAAM,EAAE,YAAY,CAAC,MAAM,CAAC,CAAC;CAC9B"}

package/dist/events/EventEmittingComponent.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+export * from "./config/ModuleContainer";
+export * from "./config/ConfigurableModule";
+export * from "./config/ChildContainerProvider";
+export * from "./config/ChildContainerCreatable";
+export * from "./types";
+export * from "./zkProgrammable/ZkProgrammable";
+export * from "./zkProgrammable/ProvableMethodExecutionContext";
+export * from "./zkProgrammable/provableMethod";
+export * from "./utils";
+export * from "./dependencyFactory/DependencyFactory";
+export * from "./dependencyFactory/injectOptional";
+export * from "./log";
+export * from "./events/EventEmittingComponent";
+export * from "./events/EventEmitter";
+export * from "./trees/MerkleTreeStore";
+export * from "./trees/InMemoryMerkleTreeStorage";
+export * from "./trees/RollupMerkleTree";
+export * from "./events/EventEmitterProxy";
+export * from "./trees/MockAsyncMerkleStore";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,SAAS,CAAC;AACxB,cAAc,iCAAiC,CAAC;AAChD,cAAc,iDAAiD,CAAC;AAChE,cAAc,iCAAiC,CAAC;AAChD,cAAc,SAAS,CAAC;AACxB,cAAc,uCAAuC,CAAC;AACtD,cAAc,oCAAoC,CAAC;AACnD,cAAc,OAAO,CAAC;AACtB,cAAc,iCAAiC,CAAC;AAChD,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8BAA8B,CAAC"}

package/dist/index.js

@@ -0,0 +1,19 @@
+export * from "./config/ModuleContainer";
+export * from "./config/ConfigurableModule";
+export * from "./config/ChildContainerProvider";
+export * from "./config/ChildContainerCreatable";
+export * from "./types";
+export * from "./zkProgrammable/ZkProgrammable";
+export * from "./zkProgrammable/ProvableMethodExecutionContext";
+export * from "./zkProgrammable/provableMethod";
+export * from "./utils";
+export * from "./dependencyFactory/DependencyFactory";
+export * from "./dependencyFactory/injectOptional";
+export * from "./log";
+export * from "./events/EventEmittingComponent";
+export * from "./events/EventEmitter";
+export * from "./trees/MerkleTreeStore";
+export * from "./trees/InMemoryMerkleTreeStorage";
+export * from "./trees/RollupMerkleTree";
+export * from "./events/EventEmitterProxy";
+export * from "./trees/MockAsyncMerkleStore";

package/dist/log.d.ts

@@ -0,0 +1,20 @@
+import loglevel, { LogLevelDesc, LogLevelNames } from "loglevel";
+export declare const log: {
+    provable: {
+        info: (...args: unknown[]) => void;
+        debug: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+        trace: (...args: unknown[]) => void;
+        warn: (...args: unknown[]) => void;
+    };
+    info: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    trace: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    setLevel: (level: LogLevelDesc) => void;
+    readonly levels: loglevel.LogLevel;
+    getLevel: () => 0 | 2 | 3 | 1 | 4 | 5;
+};
+export declare function assertValidTextLogLevel(level: string | number): asserts level is LogLevelNames;
+//# sourceMappingURL=log.d.ts.map

package/dist/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../src/log.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,EAAE,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AA2BjE,eAAO,MAAM,GAAG;;wBAEI,OAAO,EAAE;yBAIR,OAAO,EAAE;yBAIT,OAAO,EAAE;yBAIT,OAAO,EAAE;wBAIV,OAAO,EAAE;;oBAKX,OAAO,EAAE;qBAIR,OAAO,EAAE;qBAIT,OAAO,EAAE;qBAIT,OAAO,EAAE;oBAQV,OAAO,EAAE;sBAIP,YAAY;;;CAS/B,CAAC;AAIF,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,GAAG,MAAM,GACrB,OAAO,CAAC,KAAK,IAAI,aAAa,CAOhC"}

package/dist/log.js

@@ -0,0 +1,75 @@
+import loglevel from "loglevel";
+import { Provable } from "o1js";
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+function logProvable(logFunction, ...args) {
+    Provable.asProver(() => {
+        const prettyArguments = [];
+        args.forEach((argument) => {
+            if (argument?.toPretty !== undefined) {
+                prettyArguments.push(argument.toPretty());
+            }
+            else {
+                try {
+                    prettyArguments.push(JSON.parse(JSON.stringify(argument)));
+                }
+                catch {
+                    prettyArguments.push(argument);
+                }
+            }
+        });
+        logFunction(...prettyArguments);
+    });
+}
+/* eslint-enable */
+export const log = {
+    provable: {
+        info: (...args) => {
+            logProvable(loglevel.info, ...args);
+        },
+        debug: (...args) => {
+            logProvable(loglevel.debug, ...args);
+        },
+        error: (...args) => {
+            logProvable(loglevel.error, ...args);
+        },
+        trace: (...args) => {
+            logProvable(log.trace, ...args);
+        },
+        warn: (...args) => {
+            logProvable(loglevel.warn, ...args);
+        },
+    },
+    info: (...args) => {
+        loglevel.info(...args);
+    },
+    debug: (...args) => {
+        loglevel.debug(...args);
+    },
+    error: (...args) => {
+        loglevel.error(...args);
+    },
+    trace: (...args) => {
+        // Loglevel prints the stack trace by default. To still be able to use trace
+        // inside out application, we use the level, but call debug() under the hood
+        if (loglevel.getLevel() <= loglevel.levels.TRACE) {
+            loglevel.debug(...args);
+        }
+    },
+    warn: (...args) => {
+        loglevel.warn(...args);
+    },
+    setLevel: (level) => {
+        loglevel.setLevel(level);
+    },
+    get levels() {
+        return loglevel.levels;
+    },
+    getLevel: () => loglevel.getLevel(),
+};
+const validLogLevels = ["TRACE", "DEBUG", "INFO", "WARN", "ERROR", "SILENT"];
+export function assertValidTextLogLevel(level) {
+    if (typeof level === "number" ||
+        !validLogLevels.includes(level.toUpperCase())) {
+        throw new Error(`${level} is not a valid loglevel`);
+    }
+}