shogun-core 1.2.0 → 1.2.3

package/dist/types/gundb/models/auth/auth.d.ts

@@ -1,121 +0,0 @@
-import { GunUser, ISEAPair } from "gun";
-import { GunDB } from "../../gun";
-import { StateMachineEvent } from "./state-machine";
-/** A valid user alias. Must be checked with the as_alias function. */
-export type GunAlias = string & {
-    _value: never;
-};
-/** A valid user password. Must be checked with the AuthManager.validate function. */
-export type GunPassword = string & {
-    _value: never;
-};
-/** An auth manager that wraps gun.user logic. */
-export default class AuthManager {
-    static INITIAL_STATE: "disconnected";
-    static state: {
-        subscribe: (cb: (state: import("./state-machine").AUTH_STATE) => any) => () => void;
-        set: (event: StateMachineEvent) => void;
-        getCurrentState: () => import("./state-machine").AUTH_STATE;
-        waitForState: (targetState: import("./state-machine").AUTH_STATE, timeoutMs?: number) => Promise<boolean>;
-        isAuthenticated: () => boolean;
-        isWalletReady: () => boolean;
-    };
-    static instance: AuthManager;
-    gundb: GunDB;
-    app_scope: string;
-    /** Returns the validated alias and password information. This will also be scoped using app_scope */
-    validate(alias: string, password: string): Promise<{
-        alias: GunAlias;
-        password: GunPassword;
-    }>;
-    /** A new AuthManager. */
-    constructor(gundb: GunDB, appScope?: string);
-    /** Gets the user chain, if authenticated. */
-    get chain(): import("gun").IGunChain<any, import("gun").IGunInstance<any>, import("gun").IGunInstance<any>, string>;
-    /**
-     * Attempt to get the pair of the currently logged in user.
-     *
-     * You may do `pair({strict})` to throw if the user is not authenticated.
-     * */
-    pair(options: {
-        strict: true;
-    }): ISEAPair;
-    pair(options?: {
-        strict?: false;
-    }): ISEAPair | undefined;
-    /**
-     * Generate a new gun user pair using alias and password.
-     *
-     * @param alias - The user alias.
-     * @param password - The user password.
-     * @returns A promise that resolves with gun ack or rejects with gun ack on errors.
-     */
-    create: ({ alias, password, }: {
-        alias: GunAlias;
-        password: GunPassword;
-    }) => Promise<{
-        ok: 0;
-        pub: string;
-    } | {
-        err: string;
-    }>;
-    /**
-     * Authenicate existing gun user using either a pair or a alias/password combination.
-     * @returns A promise that resolves with gun ack or rejects with gun ack on errors.
-     */
-    auth: (info: {
-        alias: GunAlias;
-        password: GunPassword;
-    } | ISEAPair) => Promise<GunAuthAck>;
-    /**
-     * Un-authenticates the currently authenticated gun user.
-     */
-    leave: () => Promise<{
-        success: true;
-    }>;
-    /**
-     * A simple default certificate that will allow everybody to write to the users graph, as long as the key or path contains their public key.
-     */
-    certify(): null;
-    /**
-     * Start wallet initialization process
-     */
-    startWalletInit(): void;
-    /**
-     * Mark wallet initialization as successful
-     */
-    walletInitSuccess(): void;
-    /**
-     * Mark wallet initialization as failed
-     */
-    walletInitFail(error?: any): void;
-    /**
-     * Wait for authentication to complete
-     */
-    waitForAuthentication(timeoutMs?: number): Promise<boolean>;
-    /**
-     * Wait for wallet to be ready
-     */
-    waitForWalletReady(timeoutMs?: number): Promise<boolean>;
-    /**
-     * Check if user is authenticated
-     */
-    isAuthenticated(): boolean;
-    /**
-     * Check if wallet is ready
-     */
-    isWalletReady(): boolean;
-    /**
-     * Get current authentication state
-     */
-    getCurrentState(): "wallet_initializing" | "wallet_ready" | "disconnected" | "creating" | "pending" | "authorized" | "leaving";
-}
-export type GunAuthAck = {
-    ack: 2;
-    soul: string;
-    get: string;
-    put: GunUser;
-    sea: ISEAPair;
-} | {
-    err: string;
-};

package/dist/types/gundb/models/auth/state-machine.d.ts

@@ -1,70 +0,0 @@
-/** Transistion function that takes a state and event and outputs a new state */
-interface Machine {
-    (state: AUTH_STATE, event: StateMachineEvent): AUTH_STATE;
-}
-/** A state machine event with optional data */
-export declare class StateMachineEvent {
-    type: AUTH_EVENT;
-    data: any;
-    constructor(type: AUTH_EVENT, data?: any);
-}
-/**
- *
- * @param machine - A machine function that defines state transitions.
- * @param initial - The initial state of the machine.
- */
-export declare function use_machine(machine: Machine, initial: AUTH_STATE): {
-    /**
-     * Subscribe to state updates.
-     * @returns an unsubscriber */
-    subscribe: (cb: (state: AUTH_STATE) => any) => () => void;
-    /** attempt to update the state machine */
-    set: (event: StateMachineEvent) => void;
-    /** Get the current state */
-    getCurrentState: () => AUTH_STATE;
-    /** Wait for a specific state */
-    waitForState: (targetState: AUTH_STATE, timeoutMs?: number) => Promise<boolean>;
-    /** Check if user is authenticated */
-    isAuthenticated: () => boolean;
-    /** Check if wallet is ready */
-    isWalletReady: () => boolean;
-};
-/** Possible states that the auth-manager can be in. */
-export declare const states: {
-    /** The user is in an un-busy and unauthorized state.*/
-    disconnected: "disconnected";
-    /** A user is currently being created. */
-    creating: "creating";
-    /** A user is currently being authorized. */
-    pending: "pending";
-    /** The user is in an un-busy and authorized state. */
-    authorized: "authorized";
-    /** The user is currently logging out. */
-    leaving: "leaving";
-    /** Wallet initialization is in progress. */
-    wallet_initializing: "wallet_initializing";
-    /** Wallet is ready and available. */
-    wallet_ready: "wallet_ready";
-};
-/** Possible events that the auth-manager can take. */
-export declare const events: {
-    create: "create";
-    authenticate: "authenticate";
-    disconnect: "disconnect";
-    fail: "fail";
-    success: "success";
-    wallet_init_start: "wallet_init_start";
-    wallet_init_success: "wallet_init_success";
-    wallet_init_fail: "wallet_init_fail";
-};
-export type AUTH_EVENT = keyof typeof events;
-export type AUTH_STATE = keyof typeof states;
-/**
- * Defines possible transitions from the states in the auth manager.
- *
- * @param state - The current state.
- * @param event The event that has happend.
- * @returns The new state.
- */
-export declare function auth_state_machine(state: AUTH_STATE, event: StateMachineEvent): AUTH_STATE;
-export {};

package/dist/types/gundb/models/streams.d.ts

@@ -1,67 +0,0 @@
-import type { IGunChain } from "gun";
-interface GunNode {
-    chain: IGunChain<any>;
-}
-interface GunNodeClassSimple<T extends GunNode> {
-    new (chain: IGunChain<any>): T;
-}
-export type ValidGunChunk = {
-    key: string;
-    value: any;
-    chain: IGunChain<any>;
-};
-export type NullGunChunk = {
-    key: string;
-    value: null;
-    chain: null;
-};
-export type ValidGunNodeChunk<T extends GunNode> = {
-    key: string;
-    value: any;
-    node: T;
-};
-export type NullGunNodeChunk = {
-    key: string;
-    value: any;
-    node: null;
-};
-declare global {
-    interface ReadableStream<R> {
-        [Symbol.asyncIterator](): AsyncIterableIterator<R>;
-    }
-}
-/**
- *
- * Wraps .on call in a stream. Cancelling the stream will unsubscribe from updates from gun.
- *
- * **Usage:**
- * ```
- * const stream = on_stream(node)
- * for await (const chunk of stream) {
- *    // Do something with each 'chunk'
- * }
- * ```
- */
-export declare function on_stream(chain: IGunChain<any>): ReadableStream<ValidGunChunk | NullGunChunk>;
-/**
- *
- * Takes an incoming stream, but only issues updates if the data changes from valid data to null data.
- * You can use this to keep a list in sync with the gun state. If data is tombstoned, it can be removed from the list.
- *
- * **Example:**
- * ```
- * const map = new Map();
- * const items = [];
- * const stream = on_stream(node).pipeThrough(unique_transformer());
- * for await (const chunk of stream) {
- *      chunk.value === null ? map.delete(chunk.key) : map.set(chunk.key, chunk.chain);
-        items.splice(0, items.length, ...map.values());
- * }
- * ```
- */
-export declare function to_unique(): TransformStream<ValidGunChunk | NullGunChunk, ValidGunChunk | NullGunChunk>;
-/**
- * Transoforms a stream of gun chains into a stream of gun nodes.
- */
-export declare function to_node<T extends GunNode = GunNode>(target: GunNodeClassSimple<T>): TransformStream<ValidGunChunk | NullGunChunk, NullGunNodeChunk | ValidGunNodeChunk<T>>;
-export {};