@hub3js/core 0.59.0 → 0.59.1-next.1

package/dist/builders/action.d.ts

@@ -0,0 +1,22 @@
+import type { Actions, Context, Operators } from '../hub/namespaces/types.js';
+import type { AnyFunction, FunctionWithContext } from '../hub/types.js';
+export interface ActionByBuilder<T, Context> {
+    actionName: keyof T;
+    and: Operators<T>;
+    or: Operators<T>;
+    after: Operators<T>;
+    before: Operators<T>;
+    action: FunctionWithContext<T[keyof T], Context>;
+}
+export declare class ActionBuilder<T extends Actions<T>, K extends keyof T> {
+    #private;
+    readonly name: K;
+    constructor(name: K);
+    and(action: FunctionWithContext<AnyFunction, Context<T>>): this;
+    or(action: FunctionWithContext<AnyFunction, Context<T>>): this;
+    before(action: FunctionWithContext<AnyFunction, Context<T>>): this;
+    after(action: FunctionWithContext<AnyFunction, Context<T>>): this;
+    action(action: FunctionWithContext<T[keyof T], Context<T>>): this;
+    build(): ActionByBuilder<T, Context<T>>;
+}
+//# sourceMappingURL=action.d.ts.map

package/dist/builders/action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../src/builders/action.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC9E,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAExE,MAAM,WAAW,eAAe,CAAC,CAAC,EAAE,OAAO;IACzC,UAAU,EAAE,MAAM,CAAC,CAAC;IACpB,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IAClB,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACjB,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACpB,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;IACrB,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;CAClD;AAYD,qBAAa,aAAa,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC;;IAChE,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;gBAOL,IAAI,EAAE,CAAC;IAIZ,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAQxD,EAAE,CAAC,MAAM,EAAE,mBAAmB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAQvD,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAQ3D,KAAK,CAAC,MAAM,EAAE,mBAAmB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAQ1D,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAK1D,KAAK,IAAI,eAAe,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;CAc/C"}

package/dist/builders/mod.d.ts

@@ -0,0 +1,5 @@
+export type { ProxiedNamespace, FindProxiedNamespace } from './types.js';
+export { NamespaceBuilder } from './namespace.js';
+export { ProviderBuilder } from './provider.js';
+export { ActionBuilder } from './action.js';
+//# sourceMappingURL=mod.d.ts.map

package/dist/builders/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/builders/mod.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}

package/dist/builders/namespace.d.ts

@@ -0,0 +1,47 @@
+import type { ActionByBuilder } from './action.js';
+import type { ProxiedNamespace } from './types.js';
+import type { Actions, Context } from '../hub/namespaces/mod.js';
+import type { NamespaceConfig } from '../hub/store/mod.js';
+import type { FunctionWithContext } from '../hub/types.js';
+/**
+ * There are Namespace's methods that should be called directly on Proxy object.
+ * The Proxy object is creating in `.build`.
+ */
+export declare const allowedMethods: readonly ["init", "state", "after", "before", "and_then", "or_else", "store"];
+export declare class NamespaceBuilder<T extends Actions<T>> {
+    #private;
+    constructor(id: string, providerId: string);
+    /** There are some predefined configs that can be set for each namespace separately */
+    config<K extends keyof NamespaceConfig>(name: K, value: NamespaceConfig[K]): this;
+    /**
+     * Getting a list of actions.
+     *
+     * e.g.:
+     * ```ts
+     * .action([
+     *      ["connect", () => {}],
+     *      ["disconnect", () => {}]
+     * ])
+     * ```
+     *
+     */
+    action<K extends keyof T>(action: (readonly [K, FunctionWithContext<T[K], Context<T>>])[]): NamespaceBuilder<T>;
+    /**
+     *
+     * Add a single action
+     *
+     * e.g.:
+     * ```ts
+     * .action( ["connect", () => {}] )
+     * ```
+     */
+    action<K extends keyof T>(action: K, actionFn: FunctionWithContext<T[K], Context<T>>): NamespaceBuilder<T>;
+    action(action: ActionByBuilder<T, Context<T>>): NamespaceBuilder<T>;
+    /**
+     * By calling build, an instance of Namespace will be built.
+     *
+     * Note: it's not exactly a `Namespace`, it returns a Proxy which add more convenient use like `namespace.connect()` instead of `namespace.run("connect")`
+     */
+    build(): ProxiedNamespace<T>;
+}
+//# sourceMappingURL=namespace.d.ts.map

package/dist/builders/namespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.d.ts","sourceRoot":"","sources":["../../src/builders/namespace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAc,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAC7E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAI3D;;;GAGG;AACH,eAAO,MAAM,cAAc,+EAQjB,CAAC;AAaX,qBAAa,gBAAgB,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC;;gBAYpC,EAAE,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;IAM1C,sFAAsF;IAC/E,MAAM,CAAC,CAAC,SAAS,MAAM,eAAe,EAC3C,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,eAAe,CAAC,CAAC,CAAC;IAM3B;;;;;;;;;;;OAWG;IACI,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,EAC7B,MAAM,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,GAC9D,gBAAgB,CAAC,CAAC,CAAC;IAEtB;;;;;;;;OAQG;IACI,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,EAC7B,MAAM,EAAE,CAAC,EACT,QAAQ,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,GAC9C,gBAAgB,CAAC,CAAC,CAAC;IAEf,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC;IA0C1E;;;;OAIG;IACI,KAAK,IAAI,gBAAgB,CAAC,CAAC,CAAC;CAwHpC"}

package/dist/builders/provider.d.ts

@@ -0,0 +1,37 @@
+import type { ProxiedNamespace } from './types.js';
+import type { Actions } from '../hub/namespaces/mod.js';
+import type { ExtendableInternalActions, ProviderBuilderOptions } from '../hub/provider/mod.js';
+import type { ProviderConfig } from '../hub/store/mod.js';
+import { Provider } from '../hub/provider/mod.js';
+/**
+ * Fluent builder for `Provider`. Each `.add(key, namespace)` call accumulates
+ * the registered namespace map into the `TNS` generic, so the resulting
+ * `Provider<TNS>` knows exactly which namespaces it owns.
+ *
+ * @example
+ * ```ts
+ * const phantom = new ProviderBuilder('phantom')
+ *   .config('metadata', meta)
+ *   .add('evm', evmNamespace)        // adds { evm: EvmActions }
+ *   .add('solana', solanaNamespace)  // adds { solana: SolanaActions }
+ *   .build();
+ * // Provider<{ evm: EvmActions; solana: SolanaActions }>
+ * ```
+ * `{}` is intentional: identity element under intersection so the first
+ * `.add(K, T)` produces `{} & Record<K, T> = Record<K, T>` and subsequent calls
+ * accumulate cleanly. Not the unsafe "any non-nullish" usage the rule targets.
+ */
+export declare class ProviderBuilder<TNS = {}> {
+    #private;
+    constructor(id: string, options?: ProviderBuilderOptions);
+    /**
+     * Register a namespace under `id`. Captures both the key and the namespace's
+     * action interface into the builder's `TNS` so subsequent operations are
+     * statically typed against the accumulated set.
+     */
+    add<const K extends string, T extends Actions<T>>(id: K, namespace: ProxiedNamespace<T>): ProviderBuilder<TNS & Record<K, T>>;
+    config<K extends keyof ProviderConfig<TNS>>(name: K, value: ProviderConfig<TNS>[K]): this;
+    init(cb: Exclude<ExtendableInternalActions['init'], undefined>): this;
+    build(): Provider<TNS>;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/builders/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../src/builders/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AACxD,OAAO,KAAK,EACV,yBAAyB,EACzB,sBAAsB,EAEvB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAElD;;;;;;;;;;;;;;;;;GAiBG;AAEH,qBAAa,eAAe,CAAC,GAAG,GAAG,EAAE;;gBAWvB,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB;IAKxD;;;;OAIG;IACI,GAAG,CAAC,KAAK,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,EACrD,EAAE,EAAE,CAAC,EACL,SAAS,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAC7B,eAAe,CAAC,GAAG,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAQ/B,MAAM,CAAC,CAAC,SAAS,MAAM,cAAc,CAAC,GAAG,CAAC,EAC/C,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAC5B,IAAI;IAKA,IAAI,CAAC,EAAE,EAAE,OAAO,CAAC,yBAAyB,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,GAAG,IAAI;IAKrE,KAAK,IAAI,QAAQ,CAAC,GAAG,CAAC;CAyB9B"}

package/dist/builders/types.d.ts

@@ -0,0 +1,23 @@
+import type { allowedMethods } from './namespace.js';
+import type { Actions, Namespace } from '../hub/namespaces/mod.js';
+type NamespacePublicValues = {
+    namespaceId: string;
+    providerId: string;
+};
+/**
+ * NamespaceBuilder is creating a proxy instead of return Namespace instance.
+ * The reason is improving access to actions. e.g `.connect()` instead of `.run('connect')`
+ */
+export type ProxiedNamespace<T extends Actions<T>> = T & Pick<Namespace<T>, (typeof allowedMethods)[number]> & NamespacePublicValues;
+/**
+ * Map a key into the corresponding proxied namespace inside a namespace set.
+ *
+ * @example
+ * ```ts
+ * type List = { evm: EvmActions; solana: SolanaActions };
+ * FindProxiedNamespace<'solana', List>;   // ProxiedNamespace<SolanaActions>
+ * ```
+ */
+export type FindProxiedNamespace<K extends keyof T, T> = T[K] extends Actions<T[K]> ? ProxiedNamespace<T[K]> : never;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/builders/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/builders/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAGnE,KAAK,qBAAqB,GAAG;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,GACpD,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC,GACnD,qBAAqB,CAAC;AAExB;;;;;;;;GAQG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,CAAC,IACnD,CAAC,CAAC,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC"}

package/dist/hub/helpers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Note: This only works native async, if we are going to support for old transpilers like Babel.
+ */
+export declare function isAsync(fn: Function): boolean;
+export declare function generateStoreId(providerId: string, namespace: string): string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/hub/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/hub/helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,wBAAgB,OAAO,CAAC,EAAE,EAAE,QAAQ,WAEnC;AAED,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,UAEpE"}

package/dist/hub/hub.d.ts

@@ -0,0 +1,44 @@
+import type { State as NamespaceState } from './namespaces/mod.js';
+import type { Provider, State as ProviderState } from './provider/mod.js';
+import type { Store } from './store/mod.js';
+/**
+ * Hub stores providers with heterogeneous `TNS` shapes. `Provider<TNS>` is
+ * invariant in `TNS` (TNS appears in both reading and writing positions via
+ * the internal `Map`), so the only universally-assignable upper bound is
+ * `Provider<any>`. Concrete TNS information is preserved on each `Provider`
+ * instance itself — consumers recover precise types via `provider.get('evm')`.
+ *
+ * TODO: consider making `Provider<TNS>` covariant in TNS so this `any` can be
+ * replaced with `Provider<unknown>`. Requires switching the internal storage
+ * to a covariant container (e.g. `ReadonlyMap` semantics), moving TNS-typed
+ * constructor inputs out of the public class surface (factory pattern or
+ * interface + impl), and dropping TNS info from `getAll()`'s return type.
+ * Bigger surgery than this PR; deserves its own review cycle.
+ */
+type AnyProvider = Provider<any>;
+type HubState = {
+    [key in string]: ProviderState & {
+        namespaces: NamespaceState[];
+    };
+};
+type RunAllResult = {
+    id: string;
+    provider: unknown;
+    namespaces: unknown[];
+};
+interface HubOptions {
+    store?: Store;
+}
+export declare class Hub {
+    #private;
+    constructor(options?: HubOptions);
+    init(): void;
+    runAll(action: string): RunAllResult[];
+    add(id: string, provider: AnyProvider): this;
+    remove(id: string): this;
+    get(providerId: string): AnyProvider | undefined;
+    getAll(): Map<string, AnyProvider>;
+    state(): HubState;
+}
+export {};
+//# sourceMappingURL=hub.d.ts.map

package/dist/hub/hub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hub.d.ts","sourceRoot":"","sources":["../../src/hub/hub.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,KAAK,IAAI,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC9E,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,IAAI,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;;;;GAaG;AAEH,KAAK,WAAW,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC;AAEjC,KAAK,QAAQ,GAAG;KACb,GAAG,IAAI,MAAM,GAAG,aAAa,GAAG;QAC/B,UAAU,EAAE,cAAc,EAAE,CAAC;KAC9B;CACF,CAAC;AAEF,KAAK,YAAY,GAAG;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,EAAE,OAAO,EAAE,CAAC;CACvB,CAAC;AAEF,UAAU,UAAU;IAClB,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED,qBAAa,GAAG;;gBAIF,OAAO,CAAC,EAAE,UAAU;IAIhC,IAAI;IASJ,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,EAAE;IAqCtC,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,GAAG,IAAI;IAQ5C,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAaxB,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAIhD,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC;IAIlC,KAAK,IAAI,QAAQ;CAwBlB"}

package/dist/hub/mod.d.ts

@@ -0,0 +1,9 @@
+export type { Actions, Subscriber, SubscriberCleanUp, Context, } from './namespaces/mod.js';
+export { Namespace } from './namespaces/mod.js';
+export { Provider } from './provider/mod.js';
+export type { RegisteredNamespaces } from './provider/mod.js';
+export { Hub } from './hub.js';
+export type { Store, State, ProviderMetadata } from './store/mod.js';
+export { createStore, guessProviderStateSelector, namespaceStateSelector, } from './store/mod.js';
+export { generateStoreId } from './helpers.js';
+//# sourceMappingURL=mod.d.ts.map

package/dist/hub/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../src/hub/mod.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,OAAO,EACP,UAAU,EACV,iBAAiB,EACjB,OAAO,GACR,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAEhD,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,YAAY,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACrE,OAAO,EACL,WAAW,EACX,0BAA0B,EAC1B,sBAAsB,GACvB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC"}

package/dist/hub/namespaces/errors.d.ts

@@ -0,0 +1,5 @@
+export declare const ACTION_NOT_FOUND_ERROR: (name: string) => string;
+export declare const OR_ELSE_ACTION_FAILED_ERROR: (name: string) => string;
+export declare const BEFORE_ACTION_FAILED_ERROR: (name: string) => string;
+export declare const NO_STORE_FOUND_ERROR = "For setup store, you should set `store` first.";
+//# sourceMappingURL=errors.d.ts.map

package/dist/hub/namespaces/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/hub/namespaces/errors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,SAAU,MAAM,WACsB,CAAC;AAE1E,eAAO,MAAM,2BAA2B,SAAU,MAAM,WACZ,CAAC;AAE7C,eAAO,MAAM,0BAA0B,SAAU,MAAM,WACS,CAAC;AAEjE,eAAO,MAAM,oBAAoB,mDACiB,CAAC"}

package/dist/hub/namespaces/mod.d.ts

@@ -0,0 +1,3 @@
+export type { Subscriber, SubscriberCleanUp, State, RegisteredActions as ActionsMap, Context, Actions, } from './types.js';
+export { Namespace } from './namespace.js';
+//# sourceMappingURL=mod.d.ts.map

package/dist/hub/namespaces/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/hub/namespaces/mod.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,iBAAiB,EACjB,KAAK,EACL,iBAAiB,IAAI,UAAU,EAC/B,OAAO,EACP,OAAO,GACR,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/hub/namespaces/namespace.d.ts

@@ -0,0 +1,148 @@
+import type { Actions, Context, GetState, RegisteredActions, SetState } from './types.js';
+import type { NamespaceConfig, Store } from '../store/mod.js';
+import type { AndFunction, AnyFunction, FunctionWithContext } from '../types.js';
+type Params = any[];
+/**
+ *
+ * A Namespace is a unit of wallets where usually handles connecting, signing, accounts, ...
+ * It will be injected by wallet in its object, for example, `window.phantom.ethereum` or `window.phantom.solana`
+ * Each namespace (like solana) has its own functionality which is not shared between all the blockchains.
+ * For example in EVM namespaces, you can have different networks (e.g. Ethereum,Polygon, ...) and there are specific flows to handle connecting to them or add a network and etc.
+ * But Solana doesn't have this concept and you will directly always connect to solana itself.
+ * This is true for signing a transaction, getting information about blockchain and more.
+ * So by creating a namespace for each of these, we can define a custom namespace based on blockchain's properties.
+ *
+ */
+declare class Namespace<T extends Actions<T>> {
+    #private;
+    /** it will be used for `store` and accessing to store by its id mainly. */
+    readonly namespaceId: string;
+    /** it will be used for `store` and accessing to store by its id mainly. */
+    readonly providerId: string;
+    constructor(id: string, providerId: string, options: {
+        store?: Store;
+        configs?: NamespaceConfig;
+        actions: RegisteredActions<T>;
+    });
+    /**
+     * This is an special action that will be called **only once**.
+     * We don't call this in `constructor` and developer should call this manually. we only ensure it will be called once.
+     *
+     * ```ts
+     * const myInit = () => {  whatever; }
+     * const actions = new Map();
+     * actions.set("init", myInit)
+     * const ns = new Namespace(..., {actions});
+     *
+     * // Will run `myInit`
+     * ns.init()
+     *
+     * // Will not run `myInit` anymore.
+     * ns.init()
+     * ns.init()
+     * ```
+     */
+    init(): void;
+    /**
+     * Reading states from store and also update them.
+     *
+     * @example
+     * ```ts
+     * const ns = new Namespace(...);
+     * const [getState, setState] = ns.state();
+     * ```
+     */
+    state(): [GetState, SetState];
+    /**
+     * For keeping state, we need a store. all the states will be write to/read from store.
+     *
+     * Note: Store can be setup on constructor as well.
+     *
+     * @example
+     * ```ts
+     * const myStore = createStore();
+     * const ns = new Namespace(...);
+     * ns.store(myStore);
+     * ```
+     */
+    store(store: Store): this;
+    /**
+     * It's a boolean operator to run a sync function if action ran successfully.
+     * For example, if we have a `connect` action, we can add function to be run after `connect` if it ran successfully.
+     *
+     * @example
+     * ```ts
+     *  const ns = new Namespace(..);
+     *
+     *  ns.and_then('connect', (context) => {
+     *    ...
+     *  });
+     * ```
+     *
+     */
+    and_then<K extends keyof T>(actionName: K, operatorFn: FunctionWithContext<AndFunction<T, K>, Context>): this;
+    /**
+     * It's a boolean operator to run a function to handle when an action fails.
+     * For example, if we have a `connect` action, we can add function to be run when `connect` fails (throw an error).
+     *
+     * @example
+     * ```ts
+     *  const ns = new Namespace(..);
+     *
+     *  ns.or_else('connect', (context, error) => {
+     *    ...
+     *  });
+     * ```
+     */
+    or_else<K extends keyof T>(actionName: K, operatorFn: FunctionWithContext<AnyFunction, Context>): this;
+    /**
+     * Running a function after a specific action
+     *
+     * Note: the context can be set from outside as well. this is useful for Provider to set its context instead of namespace context.
+     *
+     * @example
+     * ```ts
+     *  const ns = new Namespace(...);
+     *
+     *  ns.after("connect", (context) => {});
+     * ```
+     */
+    after<K extends keyof T, C = unknown>(actionName: K, hook: FunctionWithContext<AnyFunction, C>, options?: {
+        context?: C;
+    }): this;
+    /**
+     * Running a function before a specific action
+     *
+     * Note: the context can be set from outside as well. this is useful for Provider to set its context instead of using namespace context.
+     *
+     * @example
+     * ```ts
+     *  const ns = new Namespace(...);
+     *
+     *  ns.before("connect", (context) => {});
+     * ```
+     */
+    before<K extends keyof T, C = unknown>(actionName: K, hook: FunctionWithContext<AnyFunction, C>, options?: {
+        context?: C;
+    }): this;
+    has<K extends keyof T>(actionName: K): boolean;
+    /**
+     *
+     * Registered actions will be called using `run`. it will run an action and all the operators or hooks that assigned.
+     *
+     * @example
+     * ```ts
+     *  const actions = new Map();
+     *  actions.set('connect', connectAction);
+     *
+     *  const ns = new Namespace(NAMESPACE, PROVIDER_ID, {
+     *    actions: actions,
+     *  });
+     *
+     *  ns.run("action");
+     * ```
+     */
+    run<K extends keyof T>(actionName: K, ...args: Params): unknown | Promise<unknown>;
+}
+export { Namespace };
+//# sourceMappingURL=namespace.d.ts.map

package/dist/hub/namespaces/namespace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace.d.ts","sourceRoot":"","sources":["../../../src/hub/namespaces/namespace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,OAAO,EACP,QAAQ,EAGR,iBAAiB,EACjB,QAAQ,EAET,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC9D,OAAO,KAAK,EACV,WAAW,EACX,WAAW,EACX,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAYrB,KAAK,MAAM,GAAG,GAAG,EAAE,CAAC;AAEpB;;;;;;;;;;GAUG;AACH,cAAM,SAAS,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC;;IAClC,2EAA2E;IAC3E,SAAgB,WAAW,EAAE,MAAM,CAAC;IACpC,2EAA2E;IAC3E,SAAgB,UAAU,EAAE,MAAM,CAAC;gBAgBjC,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE;QACP,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,OAAO,CAAC,EAAE,eAAe,CAAC;QAC1B,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;KAC/B;IAeH;;;;;;;;;;;;;;;;;OAiBG;IACI,IAAI,IAAI,IAAI;IAenB;;;;;;;;OAQG;IACI,KAAK,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC;IA0BpC;;;;;;;;;;;OAWG;IACI,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAYhC;;;;;;;;;;;;;OAaG;IACI,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,EAC/B,UAAU,EAAE,CAAC,EACb,UAAU,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,GAC1D,IAAI;IAOP;;;;;;;;;;;;OAYG;IACI,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,EAC9B,UAAU,EAAE,CAAC,EACb,UAAU,EAAE,mBAAmB,CAAC,WAAW,EAAE,OAAO,CAAC,GACpD,IAAI;IAOP;;;;;;;;;;;OAWG;IACI,KAAK,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,CAAC,GAAG,OAAO,EACzC,UAAU,EAAE,CAAC,EACb,IAAI,EAAE,mBAAmB,CAAC,WAAW,EAAE,CAAC,CAAC,EACzC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,CAAC,CAAA;KAAE,GACxB,IAAI;IAaP;;;;;;;;;;;OAWG;IACI,MAAM,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,CAAC,GAAG,OAAO,EAC1C,UAAU,EAAE,CAAC,EACb,IAAI,EAAE,mBAAmB,CAAC,WAAW,EAAE,CAAC,CAAC,EACzC,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,CAAC,CAAA;KAAE,GACxB,IAAI;IAeA,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,OAAO;IAGrD;;;;;;;;;;;;;;;OAeG;IACI,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,EAC1B,UAAU,EAAE,CAAC,EACb,GAAG,IAAI,EAAE,MAAM,GACd,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;CAqK9B;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/hub/namespaces/types.d.ts

@@ -0,0 +1,36 @@
+import type { NamespaceData } from '../store/mod.js';
+import type { AnyFunction, FunctionWithContext } from '../types.js';
+type ActionName<K> = K | Omit<K, string>;
+type Args = any[];
+type ActionResult = any;
+export type Subscriber<C extends Actions<C>> = (context: Context<C>, ...args: Args) => void;
+export type SubscriberCleanUp<C extends Actions<C>> = (context: Context<C>, ...args: Args) => void;
+export type CanEagerConnect<C extends Actions<C>> = (context: Context<C>, ...args: Args) => void;
+export type State = NamespaceData;
+export type SetState = <K extends keyof State>(name: K, value: State[K]) => void;
+export type GetState = {
+    (): State;
+    <K extends keyof State>(name: K): State[K];
+};
+export type RegisteredActions<T extends Actions<T>> = Map<ActionName<keyof T>, FunctionWithContext<T[keyof T], Context<T>>>;
+export type AndUseActions<T> = Map<keyof T, AnyFunction>;
+export type Operators<T> = Map<keyof T, AnyFunction[]>;
+export type HooksWithOptions<T> = Map<keyof T, {
+    hook: AnyFunction;
+    options?: {
+        context?: unknown;
+    };
+}[]>;
+export type Context<T extends Actions<T> = object> = {
+    state: () => [GetState, SetState];
+    action: (name: keyof T, ...args: Args) => ActionResult;
+};
+/**
+ * This actually define what kind of action will be implemented in namespaces.
+ * For example evm namespace will have .connect(chain: string) and .switchNetwork
+ * But solana namespace only have: `.connect()`.
+ * This actions will be passed to this generic.
+ */
+export type Actions<T> = Record<keyof T, AnyFunction>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/hub/namespaces/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/hub/namespaces/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEpE,KAAK,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC;AAEzC,KAAK,IAAI,GAAG,GAAG,EAAE,CAAC;AAElB,KAAK,YAAY,GAAG,GAAG,CAAC;AAExB,MAAM,MAAM,UAAU,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,IAAI,CAC7C,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,GAAG,IAAI,EAAE,IAAI,KACV,IAAI,CAAC;AACV,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,IAAI,CACpD,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,GAAG,IAAI,EAAE,IAAI,KACV,IAAI,CAAC;AACV,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,IAAI,CAClD,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,GAAG,IAAI,EAAE,IAAI,KACV,IAAI,CAAC;AACV,MAAM,MAAM,KAAK,GAAG,aAAa,CAAC;AAClC,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,SAAS,MAAM,KAAK,EAC3C,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KACZ,IAAI,CAAC;AACV,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,KAAK,CAAC;IACV,CAAC,CAAC,SAAS,MAAM,KAAK,EAAE,IAAI,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;CAC5C,CAAC;AACF,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,IAAI,GAAG,CACvD,UAAU,CAAC,MAAM,CAAC,CAAC,EACnB,mBAAmB,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAC5C,CAAC;AAEF,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC;AACzD,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC;AACvD,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,GAAG,CACnC,MAAM,CAAC,EACP;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;CACH,EAAE,CACJ,CAAC;AACF,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,IAAI;IACnD,KAAK,EAAE,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IAClC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,KAAK,YAAY,CAAC;CACxD,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,CAAC"}

package/dist/hub/provider/mod.d.ts

@@ -0,0 +1,3 @@
+export type { ExtendableInternalActions, RegisteredNamespaces, State, Context, ProviderBuilderOptions, } from './types.js';
+export { Provider } from './provider.js';
+//# sourceMappingURL=mod.d.ts.map

package/dist/hub/provider/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../src/hub/provider/mod.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,yBAAyB,EACzB,oBAAoB,EACpB,KAAK,EACL,OAAO,EACP,sBAAsB,GACvB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC"}

package/dist/hub/provider/provider.d.ts

@@ -0,0 +1,102 @@
+import type { Context, ExtendableInternalActions, GetState, RegisteredNamespaces, SetState } from './types.js';
+import type { FindProxiedNamespace } from '../../builders/mod.js';
+import type { ProviderConfig, ProviderInfo, Store } from '../store/mod.js';
+import type { AnyFunction, FunctionWithContext } from '../types.js';
+/**
+ * A `Provider` represents one wallet/integration and owns the set of namespaces
+ * that wallet exposes (e.g. `evm`, `solana`).
+ *
+ * The `TNS` generic captures exactly which namespaces this provider supports.
+ * It's normally inferred by `ProviderBuilder` from chained `.add()` calls, so
+ * `phantom.get('cosmos')` is a compile-time error if Phantom never registered
+ * `cosmos`. Construct directly only when you have a precise namespace shape
+ * to pass via `new Provider<MyNamespaces>(...)`.
+ */
+export declare class Provider<TNS = unknown> {
+    #private;
+    readonly id: string;
+    readonly version = "1.0";
+    constructor(id: string, namespaces: RegisteredNamespaces<TNS>, configs: ProviderConfig<TNS>, options?: {
+        /**
+         * There are some cases we need to have a behavior like initializing a provider which will be run when we are creating an instance.
+         * These internal steps and behaviors will be useful for library user to extend the behavior by running a specific code.
+         */
+        extendInternalActions?: ExtendableInternalActions;
+        store?: Store;
+    });
+    /**
+     * This is an special callback that will be called **only once**.
+     * We don't call this in `constructor` and developer should call this manually. we only ensure it will be called once.
+     *
+     * ```ts
+     * const myInit = () => {  whatever; }   *
+     * const provider = new Provider(..., {extendInternalActions: {init: myInit} });
+     *
+     * // Will run `myInit`
+     * provider.init()
+     *
+     * // Will not run `myInit` anymore.
+     * provider.init()
+     * provider.init()
+     * ```
+     */
+    init(): void;
+    /**
+     * Getting state of a provider.
+     *
+     * @example
+     * ```ts
+     * const provider = new Provider(...);
+     * const [getState, setState] = provider.state();
+     *
+     * getState('installed');
+     * // or
+     * getState().installed;
+     * ```
+     */
+    state(): [GetState, SetState];
+    /**
+     * For keeping state, we need a store. all the states will be write to/read from store.
+     *
+     * **Note: When you are setting an store for provider, it will be set for its namespaces automatically as well**
+     */
+    store(store: Store): this;
+    /**
+     * Getting information about a provider which has been set on constructing Provider.
+     */
+    info(): ProviderInfo<TNS> | undefined;
+    /**
+     * A list of registered _proxied_ namespaces.
+     */
+    getAll(): RegisteredNamespaces<TNS>;
+    /**
+     * Get a registered namespace in provider by its **namespace key**.
+     *
+     * Note: difference between namespace key and namespace id is the first one
+     * is the key under which the namespace is registered (the `K` in `.add(K, ns)`),
+     * and the second one is the runtime `namespaceId` (e.g. `'eip155'`) chosen
+     * when constructing the namespace itself.
+     */
+    get<K extends keyof TNS>(id: K): FindProxiedNamespace<K, TNS> | undefined;
+    /**
+     * Get a registered namespace by its **namespaceId** (the runtime id chosen
+     * when constructing the namespace). Returns the union of all namespaces this
+     * provider supports — caller is expected to discriminate via `namespaceId`.
+     *
+     * @example
+     * ```ts
+     * const provider = new Provider(...);
+     * provider.findByNamespace("whatever-id-i-set-for-namespace")
+     * ```
+     */
+    findByNamespace(namespaceLookingFor: string): FindProxiedNamespace<keyof TNS, TNS> | undefined;
+    /**
+     * Running a hook function _before_ a specific action for **all registered namespaces**.
+     */
+    before(actionName: string, hookFn: FunctionWithContext<AnyFunction, Context>): this;
+    /**
+     * Running a hook function _after_ a specific action for **all registered namespaces**.
+     */
+    after(actionName: string, hookFn: FunctionWithContext<AnyFunction, Context>): this;
+}
+//# sourceMappingURL=provider.d.ts.map

package/dist/hub/provider/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/hub/provider/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,yBAAyB,EACzB,QAAQ,EACR,oBAAoB,EACpB,QAAQ,EAET,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAIpE;;;;;;;;;GASG;AACH,qBAAa,QAAQ,CAAC,GAAG,GAAG,OAAO;;IACjC,SAAgB,EAAE,EAAE,MAAM,CAAC;IAC3B,SAAgB,OAAO,SAAW;gBAShC,EAAE,EAAE,MAAM,EACV,UAAU,EAAE,oBAAoB,CAAC,GAAG,CAAC,EACrC,OAAO,EAAE,cAAc,CAAC,GAAG,CAAC,EAC5B,OAAO,CAAC,EAAE;QACR;;;WAGG;QACH,qBAAqB,CAAC,EAAE,yBAAyB,CAAC;QAClD,KAAK,CAAC,EAAE,KAAK,CAAC;KACf;IAkBH;;;;;;;;;;;;;;;OAeG;IACI,IAAI,IAAI,IAAI;IAanB;;;;;;;;;;;;OAYG;IACI,KAAK,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAyCpC;;;;OAIG;IACI,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAWhC;;OAEG;IACI,IAAI,IAAI,YAAY,CAAC,GAAG,CAAC,GAAG,SAAS;IAU5C;;OAEG;IACI,MAAM,IAAI,oBAAoB,CAAC,GAAG,CAAC;IAI1C;;;;;;;OAOG;IACI,GAAG,CAAC,CAAC,SAAS,MAAM,GAAG,EAC5B,EAAE,EAAE,CAAC,GACJ,oBAAoB,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS;IAI3C;;;;;;;;;;OAUG;IACI,eAAe,CACpB,mBAAmB,EAAE,MAAM,GAC1B,oBAAoB,CAAC,MAAM,GAAG,EAAE,GAAG,CAAC,GAAG,SAAS;IAYnD;;OAEG;IACI,MAAM,CACX,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,mBAAmB,CAAC,WAAW,EAAE,OAAO,CAAC,GAChD,IAAI;IAKP;;OAEG;IACI,KAAK,CACV,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,mBAAmB,CAAC,WAAW,EAAE,OAAO,CAAC,GAChD,IAAI;CA+CR"}

package/dist/hub/provider/types.d.ts

@@ -0,0 +1,28 @@
+import type { FindProxiedNamespace } from '../../builders/mod.js';
+import type { Store } from '../mod.js';
+import type { AnyFunction, FunctionWithContext } from '../types.js';
+export type Context = {
+    state: () => [GetState, SetState];
+};
+export interface State {
+    installed: boolean;
+    connected: boolean;
+    connecting: boolean;
+}
+export type SetState = <K extends keyof Pick<State, 'installed'>>(name: K, value: State[K]) => void;
+export type GetState = {
+    (): State;
+    <K extends keyof State>(name: K): State[K];
+};
+export interface ExtendableInternalActions {
+    init?: FunctionWithContext<AnyFunction, Context>;
+}
+/**
+ * The internal `Provider.#namespaces` map type — keys are the registered
+ * namespace ids, values are their corresponding proxied namespaces.
+ */
+export type RegisteredNamespaces<T> = Map<keyof T, FindProxiedNamespace<keyof T, T>>;
+export type ProviderBuilderOptions = {
+    store?: Store;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/hub/provider/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/hub/provider/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEpE,MAAM,MAAM,OAAO,GAAG;IACpB,KAAK,EAAE,MAAM,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;CACnC,CAAC;AAEF,MAAM,WAAW,KAAK;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,EAC9D,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KACZ,IAAI,CAAC;AACV,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,KAAK,CAAC;IACV,CAAC,CAAC,SAAS,MAAM,KAAK,EAAE,IAAI,EAAE,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;CAC5C,CAAC;AAEF,MAAM,WAAW,yBAAyB;IACxC,IAAI,CAAC,EAAE,mBAAmB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;CAClD;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,GAAG,CACvC,MAAM,CAAC,EACP,oBAAoB,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CACjC,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IAAE,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC"}