@novasamatech/host-papp 0.5.0-18 → 0.5.0-19

package/dist/components/user/index.js

@@ -1,58 +0,0 @@
-import { okAsync } from 'neverthrow';
-import { createSSOSession } from './ssoSession.js';
-export function createUserSessionsComponent({ userSessionStorage, storage, transport }) {
-    let unsubStatements = null;
-    const disconnect = (session) => {
-        return userSessionStorage.mutate(sessions => sessions.filter(s => s.id !== session.id)).map(() => undefined);
-    };
-    const unsubSessions = userSessionStorage.subscribe(userSessions => {
-        if (unsubStatements) {
-            unsubStatements();
-            unsubStatements = null;
-        }
-        const ssoSessions = [];
-        for (const userSession of userSessions) {
-            const session = createSSOSession({
-                ownAccount: userSession.host,
-                peerAccount: userSession.peer,
-                storage,
-                transport,
-            });
-            session.subscribe(message => {
-                switch (message.data.tag) {
-                    case 'v1': {
-                        switch (message.data.value.tag) {
-                            case 'Disconnected':
-                                return disconnect(userSession).map(() => true);
-                        }
-                    }
-                }
-                return okAsync(false);
-            });
-            ssoSessions.push(session);
-        }
-        unsubStatements = () => {
-            for (const session of ssoSessions) {
-                session.dispose();
-            }
-        };
-    });
-    return {
-        sessions: userSessionStorage,
-        disconnect,
-        destroy() {
-            unsubSessions();
-        },
-    };
-}
-// function createDisconnectMessage(ssSecret: SsSecret, topic: Uint8Array) {
-//   const statement = createStatement(ssSecret, {
-//     priority: 0,
-//     channel: createRequestChannel(topic),
-//     topics: [topic],
-//     data: SSOMessage.enc({
-//       tag: 'Disconnected',
-//       value: undefined,
-//     }),
-//   });
-// }

package/dist/components/user/ssoMessageStream.d.ts

@@ -1,10 +0,0 @@
-export declare const SSOMessage: import("scale-ts").Codec<{
-    tag: "Disconnected";
-    value: undefined;
-} | {
-    tag: "SigningRequest";
-    value: Uint8Array<ArrayBufferLike>;
-} | {
-    tag: "SigningResponse";
-    value: Uint8Array<ArrayBufferLike>;
-}>;

package/dist/components/user/ssoMessageStream.js

@@ -1,8 +0,0 @@
-import { Bytes, Enum, _void } from 'scale-ts';
-export const SSOMessage = Enum({
-    Disconnected: _void,
-    // TODO implement
-    SigningRequest: Bytes(),
-    // TODO implement
-    SigningResponse: Bytes(),
-});

package/dist/components/user/ssoSession.d.ts

@@ -1,5 +0,0 @@
-import type { SessionParams } from '../../modules/session/session.js';
-import type { Session } from '../../modules/session/types.js';
-import { HostRemoteMessageCodec } from './codec.js';
-export type SsoSession = Session<typeof HostRemoteMessageCodec>;
-export declare function createSSOSession({ ownAccount, peerAccount, transport, storage, }: Omit<SessionParams<any>, 'codec'>): SsoSession;

package/dist/components/user/ssoSession.js

@@ -1,5 +0,0 @@
-import { createSession } from '../../modules/session/session.js';
-import { HostRemoteMessageCodec } from './codec.js';
-export function createSSOSession({ ownAccount, peerAccount, transport, storage, }) {
-    return createSession({ ownAccount, peerAccount, transport, storage, codec: HostRemoteMessageCodec });
-}

package/dist/components/user/storage.d.ts

@@ -1,27 +0,0 @@
-import type { ResultAsync } from 'neverthrow';
-import type { StorageAdapter } from '../../adapters/storage/types.js';
-import type { Callback } from '../../types.js';
-import type { UserSecrets, UserSession } from './types.js';
-export type UserStorage = ReturnType<typeof createUserStorage>;
-type Params = {
-    appId: string;
-    storage: StorageAdapter;
-};
-export declare const createUserStorage: ({ appId, storage }: Params) => {
-    sessions: {
-        read(accountId: string): ResultAsync<UserSession | null, Error>;
-        readSelectedUser(): ResultAsync<UserSession | null, Error>;
-        subscribeSessions(callback: Callback<UserSession[]>): () => void;
-        create(user: UserSession, secrets: UserSecrets): ResultAsync<UserSession, Error>;
-        remove(accountId: string): ResultAsync<void, Error>;
-        readSecrets(accountId: string): ResultAsync<UserSecrets | null, Error>;
-    };
-    accounts: {
-        read(): ResultAsync<string[], Error>;
-        subscribe(callback: (accounts: string[]) => void): () => void;
-        readSelectedUser(): ResultAsync<string | null, Error>;
-        subscribeSelectedAccount(callback: (accountId: string | null) => void): VoidFunction;
-        select(accountId: string): ResultAsync<undefined, Error>;
-    };
-};
-export {};

package/dist/components/user/storage.js

@@ -1,143 +0,0 @@
-import { okAsync } from 'neverthrow';
-import { callbackRaceResolver } from '../../helpers/callbackRaceResolver.js';
-import { seq, seqAsync } from '../../helpers/result.js';
-import { nonNullable } from '../../helpers/utils.js';
-import { createSecretStorage } from '../../modules/secretStorage.js';
-import { storageListView, storageView } from '../../modules/storageView.js';
-export const createUserStorage = ({ appId, storage }) => {
-    const secretStorage = createSecretStorage(appId, storage);
-    const usersStorage = createSessionsStorage(storage);
-    const selectedUserStorage = createSelectedUserStorage(storage);
-    const store = {
-        sessions: {
-            read(accountId) {
-                const sessions = seqAsync(secretStorage.readSessionId(accountId, 'A'), secretStorage.readSessionId(accountId, 'B'));
-                return sessions.map(([sessionIdA, sessionIdB]) => {
-                    if (nonNullable(sessionIdA) && nonNullable(sessionIdB)) {
-                        return { accountId, sessionIdA, sessionIdB };
-                    }
-                    return null;
-                });
-            },
-            readSelectedUser() {
-                return store.accounts.readSelectedUser().andThen(selectedUser => {
-                    if (selectedUser === null) {
-                        return okAsync(null);
-                    }
-                    return store.sessions.read(selectedUser).andThen(user => {
-                        if (user === null) {
-                            return selectedUserStorage.clear().map(() => user);
-                        }
-                        return okAsync(user);
-                    });
-                });
-            },
-            subscribeSessions(callback) {
-                const resolver = callbackRaceResolver(callback, async (accounts) => {
-                    if (accounts.length === 0) {
-                        return [];
-                    }
-                    return seq(...(await Promise.all(accounts.map(store.sessions.read))))
-                        .map(sessions => sessions.filter(nonNullable))
-                        .unwrapOr([]);
-                });
-                return store.accounts.subscribe(resolver);
-            },
-            create(user, secrets) {
-                return usersStorage
-                    .add(user.accountId)
-                    .andThen(() => seqAsync(secretStorage.writeSsSecret(user.accountId, secrets.ss), secretStorage.writeEncrSecret(user.accountId, secrets.encr), secretStorage.writeSharedSecret(user.accountId, secrets.sharedSecret), secretStorage.writeSessionId(user.accountId, 'A', user.sessionIdA), secretStorage.writeSessionId(user.accountId, 'B', user.sessionIdB), selectedUserStorage.write(user.accountId)).map(() => user));
-            },
-            remove(accountId) {
-                const op = seqAsync(secretStorage.clearSsSecret(accountId), secretStorage.clearEncrSecret(accountId), secretStorage.clearSharedSecret(accountId), secretStorage.clearSessionId(accountId, 'A'), secretStorage.clearSessionId(accountId, 'B'), usersStorage.remove(accountId), selectedUserStorage.read());
-                // eslint-disable-next-line @typescript-eslint/no-unused-vars
-                return op.andThen(([_1, _2, _3, _4, _5, users, selectedUser]) => {
-                    if (selectedUser === accountId) {
-                        const nextSelectedUser = users.at(0);
-                        if (nextSelectedUser) {
-                            return selectedUserStorage.write(nextSelectedUser).map(() => undefined);
-                        }
-                        else {
-                            return selectedUserStorage.clear();
-                        }
-                    }
-                    return okAsync(undefined);
-                });
-            },
-            readSecrets(accountId) {
-                const op = seqAsync(secretStorage.readSsSecret(accountId), secretStorage.readEncrSecret(accountId), secretStorage.readSharedSecret(accountId));
-                return op.map(([ss, encr, sharedSecret]) => {
-                    if (nonNullable(ss) && nonNullable(encr) && nonNullable(sharedSecret)) {
-                        return { ss, encr, sharedSecret };
-                    }
-                    return null;
-                });
-            },
-        },
-        accounts: {
-            read() {
-                return usersStorage.read();
-            },
-            subscribe(callback) {
-                return usersStorage.subscribe(callback);
-            },
-            readSelectedUser() {
-                return selectedUserStorage.read();
-            },
-            subscribeSelectedAccount(callback) {
-                return selectedUserStorage.subscribe(callback);
-            },
-            select(accountId) {
-                return selectedUserStorage.write(accountId).map(() => undefined);
-            },
-        },
-    };
-    return store;
-};
-const createSessionsStorage = (storage) => {
-    const view = storageListView({
-        storage,
-        key: 'Users',
-        autosync: true,
-        initial: [],
-        from: x => JSON.parse(x),
-        to: x => JSON.stringify(x),
-    });
-    return {
-        read() {
-            return view.read();
-        },
-        add(user) {
-            return view.mutate(users => {
-                if (users.some(x => x === user)) {
-                    throw new Error(`User ${user} already exists.`);
-                }
-                return users.concat(user);
-            });
-        },
-        remove(user) {
-            return view.mutate(users => {
-                const newUsers = users.filter(x => x !== user);
-                if (newUsers.length !== users.length) {
-                    return newUsers;
-                }
-                return users;
-            });
-        },
-        subscribe(callback) {
-            return view.subscribe(v => {
-                callback(v ?? []);
-            });
-        },
-    };
-};
-const createSelectedUserStorage = (storage) => {
-    return storageView({
-        storage,
-        key: 'SelectedUser',
-        autosync: true,
-        initial: null,
-        from: x => x,
-        to: x => x,
-    });
-};

package/dist/components/user/types.d.ts

@@ -1,6 +0,0 @@
-import type { EncrSecret, SharedSecret, SsSecret } from '../../modules/crypto.js';
-export type UserSecrets = {
-    sharedSecret: SharedSecret;
-    encr: EncrSecret;
-    ss: SsSecret;
-};

package/dist/components/user/types.js

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

package/dist/components/user/userSessionStorage.d.ts

@@ -1,20 +0,0 @@
-import type { StorageAdapter } from '../../adapters/storage/types.js';
-import type { Account } from '../../modules/session/types.js';
-export type UserSessionStorage = ReturnType<typeof createUserSessionStorage>;
-export type UserSession = {
-    id: string;
-    host: Account;
-    peer: Account;
-};
-type Params = {
-    storage: StorageAdapter;
-};
-export declare const createUserSessionStorage: ({ storage }: Params) => {
-    add(value: UserSession): import("neverthrow").ResultAsync<UserSession, Error>;
-    mutate(fn: (value: UserSession[]) => UserSession[]): import("neverthrow").ResultAsync<UserSession[], Error>;
-    read(): any;
-    write(value: UserSession[]): any;
-    clear(): any;
-    subscribe(fn: (value: UserSession[]) => void): () => void;
-};
-export {};

package/dist/components/user/userSessionStorage.js

@@ -1,24 +0,0 @@
-import { fromHex, toHex } from '@polkadot-api/utils';
-import { Bytes, Option, Struct, Vector, str } from 'scale-ts';
-import { storageListView } from '../../modules/storageView.js';
-const accountCodec = Struct({
-    accountId: Bytes(),
-    publicKey: Bytes(),
-    pin: Option(str),
-});
-const userSessionCodec = Struct({
-    id: str,
-    host: accountCodec,
-    peer: accountCodec,
-});
-const userSessionsCodec = Vector(userSessionCodec);
-export const createUserSessionStorage = ({ storage }) => {
-    return storageListView({
-        storage,
-        key: 'Sessions',
-        autosync: true,
-        initial: [],
-        from: x => userSessionsCodec.dec(fromHex(x)),
-        to: x => toHex(userSessionsCodec.enc(x)),
-    });
-};

package/dist/components/user.d.ts

@@ -1,74 +0,0 @@
-import type { StatementAdapter } from '../adapters/statement/types.js';
-import type { StorageAdapter } from '../adapters/storage/types.js';
-import type { Result } from '../helpers/result.js';
-import type { EncrPublicKey, SsPublicKey } from '../modules/crypto.js';
-import type { UserSession } from '../modules/userStorage.js';
-export declare const HandshakeData: import("scale-ts").Codec<{
-    tag: "V1";
-    value: [SsPublicKey, EncrPublicKey, string];
-}>;
-export declare const HandshakeResponsePayload: import("scale-ts").Codec<{
-    tag: "V1";
-    value: [Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>];
-}>;
-export declare const HandshakeResponseSensitiveData: import("scale-ts").Codec<[Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>]>;
-export type AuthentificationStatus = {
-    step: 'none';
-} | {
-    step: 'initial';
-} | {
-    step: 'pairing';
-    payload: string;
-} | {
-    step: 'error';
-    message: string;
-} | {
-    step: 'finished';
-    user: UserSession;
-};
-type Params = {
-    /**
-     * Host app Id.
-     * CAUTION! This value should be stable.
-     */
-    appId: string;
-    /**
-     * URL for additional metadata that will be displayed during pairing process.
-     * Content of provided json shound be
-     * ```ts
-     * interface Metadata {
-     *   name: string;
-     *   icon: string; // url for icon. Icon should be a rasterized image with min size 256x256 px.
-     * }
-     * ```
-     */
-    metadata: string;
-    statements: StatementAdapter;
-    storage: StorageAdapter;
-};
-export declare function createUserComponent({ appId, metadata, statements, storage }: Params): {
-    authStatus: {
-        touched(): boolean;
-        read(): AuthentificationStatus;
-        write(value: AuthentificationStatus): AuthentificationStatus;
-        reset(): void;
-        subscribe(fn: (value: AuthentificationStatus) => void): () => void;
-        onFirstSubscribe(callback: VoidFunction): import("nanoevents").Unsubscribe;
-        onLastUnsubscribe(callback: VoidFunction): import("nanoevents").Unsubscribe;
-    };
-    storage: {
-        sessions: {
-            read(accountId: string): Promise<Result<UserSession | null>>;
-            readSelectedUser(): Promise<Result<UserSession | null>>;
-            create(user: UserSession): Promise<Result<UserSession>>;
-            remove(accountId: string): Promise<Result<void, Error>>;
-        };
-        accounts: {
-            read(): Promise<Result<string[], Error>>;
-            select(accountId: string): Promise<Result<string | null, Error> | Result<null, Error>>;
-        };
-    };
-    authenticate(): Promise<Result<UserSession | null>>;
-    abortAuthentication(): void;
-};
-export {};

package/dist/components/user.js

@@ -1,188 +0,0 @@
-import { toHex } from '@polkadot-api/utils';
-import { Bytes, Enum, Tuple, str } from 'scale-ts';
-import { err, fromPromise, ok, seq } from '../helpers/result.js';
-import { isAbortError, toError } from '../helpers/utils.js';
-import { ENCR_SECRET_SEED_SIZE, EncrPubKey, SS_SECRET_SEED_SIZE, SsPubKey, createEncrSecret, createRandomSeed, createSharedSecret, createSsSecret, createSymmetricKey, decrypt, getEncrPub, getSsPub, khash, mergeBytes, stringToBytes, } from '../modules/crypto.js';
-import { createSecretStorage } from '../modules/secretStorage.js';
-import { createSession } from '../modules/statementStore.js';
-import { createSyncStorage } from '../modules/syncStorage.js';
-import { createUserStorage } from '../modules/userStorage.js';
-// codecs
-export const HandshakeData = Enum({
-    V1: Tuple(SsPubKey, EncrPubKey, str),
-});
-export const HandshakeResponsePayload = Enum({
-    // [encrypted, tmp_key]
-    V1: Tuple(Bytes(), Bytes(65)),
-});
-export const HandshakeResponseSensitiveData = Tuple(Bytes(65), Bytes(32));
-export function createUserComponent({ appId, metadata, statements, storage }) {
-    const userStorage = createUserStorage(appId, storage);
-    const secretStorage = createSecretStorage(appId, storage);
-    const authStatus = createSyncStorage({ step: 'none' });
-    let authPromise = null;
-    let abort = null;
-    async function handshake(signal) {
-        authStatus.write({ step: 'initial' });
-        const secrets = await getSecretKeys(appId, secretStorage);
-        return secrets.andThenPromise(async ({ ssPublicKey, encrPublicKey, encrSecret }) => {
-            const handshakeTopic = createHandshakeTopic({ encrPublicKey, ssPublicKey });
-            const handshakePayload = createHandshakePayloadV1({ ssPublicKey, encrPublicKey, metadata });
-            authStatus.write({ step: 'pairing', payload: createDeeplink(handshakePayload) });
-            const statementStoreResponse = fromPromise(waitForStatements(statements, handshakeTopic, signal, (statements, resolve) => {
-                for (const statement of [...statements].reverse()) {
-                    if (!statement.data)
-                        continue;
-                    const { sessionTopic, accountId } = retrieveSessionTopic({
-                        payload: statement.data.asBytes(),
-                        encrSecret,
-                        ssPublicKey,
-                    });
-                    resolve({ sessionTopic, accountId: toHex(accountId) });
-                    break;
-                }
-            }), toError);
-            return statementStoreResponse
-                .then(x => x.andThenPromise(userStorage.sessions.create))
-                .then(async (result) => result
-                .map(user => {
-                authStatus.write({ step: 'finished', user });
-                return user;
-            })
-                .orElse(e => {
-                const error = toError(e);
-                if (isAbortError(error)) {
-                    authStatus.write({ step: 'none' });
-                    return ok(null);
-                }
-                else {
-                    authStatus.write({ step: 'error', message: error.message });
-                    return err(error);
-                }
-            }));
-        });
-    }
-    const userModule = {
-        authStatus,
-        storage: userStorage,
-        async authenticate() {
-            if (authPromise) {
-                return authPromise;
-            }
-            abort = new AbortController();
-            authPromise = handshake(abort.signal);
-            return authPromise;
-        },
-        abortAuthentication() {
-            if (abort) {
-                authPromise = null;
-                authStatus.reset();
-                abort.abort();
-            }
-        },
-    };
-    return userModule;
-}
-function createHandshakeTopic({ encrPublicKey, ssPublicKey, }) {
-    return khash(ssPublicKey, mergeBytes(encrPublicKey, stringToBytes('topic')));
-}
-function createHandshakePayloadV1({ encrPublicKey, ssPublicKey, metadata, }) {
-    return HandshakeData.enc({
-        tag: 'V1',
-        value: [ssPublicKey, encrPublicKey, metadata],
-    });
-}
-function parseHandshakePayload(payload) {
-    const decoded = HandshakeResponsePayload.dec(payload);
-    switch (decoded.tag) {
-        case 'V1':
-            return {
-                encrypted: decoded.value[0],
-                tmpKey: decoded.value[1],
-            };
-        default:
-            throw new Error('Unsupported handshake payload version');
-    }
-}
-function retrieveSessionTopic({ payload, encrSecret, ssPublicKey, }) {
-    const { encrypted, tmpKey } = parseHandshakePayload(payload);
-    const symmetricKey = createSymmetricKey(createSharedSecret(encrSecret, tmpKey));
-    const decrypted = decrypt(symmetricKey, encrypted);
-    const [pappEncrPublicKey, userPublicKey] = HandshakeResponseSensitiveData.dec(decrypted);
-    const sharedSecret = createSharedSecret(encrSecret, pappEncrPublicKey);
-    const session = createSession({
-        sharedSecret: sharedSecret,
-        accountA: ssPublicKey,
-        accountB: pappEncrPublicKey,
-    });
-    return {
-        accountId: userPublicKey,
-        sessionTopic: session.a,
-    };
-}
-async function getSsKeys(appId, secretStorage) {
-    return (await secretStorage.readSsSecret())
-        .andThenPromise(async (ssSecret) => {
-        if (ssSecret) {
-            return ok(ssSecret);
-        }
-        const seed = createRandomSeed(appId, SS_SECRET_SEED_SIZE);
-        const newSsSecret = createSsSecret(seed);
-        const write = await secretStorage.writeSsSecret(newSsSecret);
-        return write.map(() => newSsSecret);
-    })
-        .then(x => x.map(ssSecret => ({
-        ssSecret: ssSecret,
-        ssPublicKey: getSsPub(ssSecret),
-    })));
-}
-async function getEncrKeys(appId, secretStorage) {
-    return (await secretStorage.readEncrSecret())
-        .andThenPromise(async (encrSecret) => {
-        if (encrSecret) {
-            return ok(encrSecret);
-        }
-        const seed = createRandomSeed(appId, ENCR_SECRET_SEED_SIZE);
-        const newEncrSecret = createEncrSecret(seed);
-        const write = await secretStorage.writeEncrSecret(newEncrSecret);
-        return write.map(() => newEncrSecret);
-    })
-        .then(x => x.map(encrSecret => ({
-        encrSecret,
-        encrPublicKey: getEncrPub(encrSecret),
-    })));
-}
-async function getSecretKeys(appId, secretStorage) {
-    return seq(await getSsKeys(appId, secretStorage), await getEncrKeys(appId, secretStorage)).map(([ss, encr]) => ({
-        ...ss,
-        ...encr,
-    }));
-}
-function createDeeplink(payload) {
-    return `polkadotapp://pair?handshake=${toHex(payload)}`;
-}
-function waitForStatements(transport, topic, abortSignal, callback) {
-    return new Promise((resolve, reject) => {
-        const unsubscribe = transport.subscribeStatements([topic], statements => {
-            if (abortSignal?.aborted) {
-                unsubscribe();
-                try {
-                    abortSignal.throwIfAborted();
-                }
-                catch (e) {
-                    reject(e);
-                }
-            }
-            try {
-                callback(statements, value => {
-                    unsubscribe();
-                    resolve(value);
-                });
-            }
-            catch (e) {
-                unsubscribe();
-                reject(e);
-            }
-        });
-    });
-}

package/dist/helpers/result.d.ts

@@ -1,12 +0,0 @@
-import type { Result, ResultAsync } from 'neverthrow';
-type InferOk<R> = R extends Result<infer Ok, unknown> ? Ok : never;
-type InferOkAsync<R> = R extends ResultAsync<infer Ok, unknown> ? Ok : never;
-type InferErr<R> = R extends Result<unknown, infer Err> ? Err : never;
-type InferErrAsync<R> = R extends ResultAsync<unknown, infer Err> ? Err : never;
-type InferOks<Results> = Results extends [infer Head, ...infer Tail] ? [InferOk<Head>, ...InferOks<Tail>] : Results extends Result<unknown, unknown>[] ? InferOk<Results[number]>[] : [];
-type InferOksAsync<Results> = Results extends [infer Head, ...infer Tail] ? [InferOkAsync<Head>, ...InferOksAsync<Tail>] : Results extends ResultAsync<unknown, unknown>[] ? InferOkAsync<Results[number]>[] : [];
-type SeqResults<Results extends Result<unknown, unknown>[]> = Result<InferOks<Results>, InferErr<Results[number]> | Error>;
-type SeqResultsAsync<Results extends ResultAsync<unknown, unknown>[]> = ResultAsync<InferOksAsync<Results>, InferErrAsync<Results[number]> | Error>;
-export declare function seq<const Results extends Result<unknown, unknown>[]>(...result: Results): SeqResults<Results>;
-export declare function seqAsync<const Results extends ResultAsync<unknown, unknown>[]>(...result: Results): SeqResultsAsync<Results>;
-export {};

package/dist/helpers/result.js

@@ -1,15 +0,0 @@
-import { err, errAsync } from 'neverthrow';
-export function seq(...result) {
-    const [head, ...tail] = result;
-    if (head === undefined) {
-        return err(new Error('Seq is empty'));
-    }
-    return tail.reduce((a, r) => a.andThen(av => r.map(rv => [...av, rv])), head.map(r => [r]));
-}
-export function seqAsync(...result) {
-    const [head, ...tail] = result;
-    if (head === undefined) {
-        return errAsync(new Error('Seq is empty'));
-    }
-    return tail.reduce((a, r) => a.andThen(av => r.map(rv => [...av, rv])), head.map(r => [r]));
-}

package/dist/helpers/result.spec.d.ts

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

package/dist/helpers/result.spec.js

@@ -1,23 +0,0 @@
-import { err, errAsync, ok, okAsync } from 'neverthrow';
-import { describe, expect, it } from 'vitest';
-import { seq, seqAsync } from './result.js';
-describe('Result', () => {
-    describe('seq', () => {
-        it('should concat ok values', () => {
-            expect(seq(ok(1), ok('2'))._unsafeUnwrap()).toEqual([1, '2']);
-        });
-        it('should fallback to err', () => {
-            expect(seq(ok(1), err('2')).orElse(ok)._unsafeUnwrap()).toEqual('2');
-            expect(seq(err(1), ok('2')).orElse(ok)._unsafeUnwrap()).toEqual(1);
-        });
-    });
-    describe('seqAsync', () => {
-        it('should concat ok values', async () => {
-            expect((await seqAsync(okAsync(1), okAsync('2')))._unsafeUnwrap()).toEqual([1, '2']);
-        });
-        it('should fallback to err', async () => {
-            await expect(seqAsync(okAsync(1), errAsync('2')).then(x => x._unsafeUnwrapErr())).resolves.toEqual('2');
-            await expect(seqAsync(errAsync(1), okAsync('2')).then(x => x._unsafeUnwrapErr())).resolves.toEqual(1);
-        });
-    });
-});

package/dist/helpers.d.ts

@@ -1 +0,0 @@
-export declare function isAbortError(err: object): boolean;

package/dist/helpers.js

@@ -1,3 +0,0 @@
-export function isAbortError(err) {
-    return err && 'name' in err && err.name === 'AbortError';
-}

package/dist/modules/accounts.d.ts

@@ -1 +0,0 @@
-export declare function getAccountsFlow(): void;

package/dist/modules/accounts.js

@@ -1,2 +0,0 @@
-// TODO implement
-export function getAccountsFlow() { }