@novasamatech/host-papp 0.5.0-1 → 0.5.0-11

package/dist/components/user/storage.js

@@ -0,0 +1,143 @@
+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

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

package/dist/components/user/types.js

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

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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,188 @@
+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/constants.d.ts

@@ -1 +1,2 @@
-export declare const SS_ENDPOINTS: string[];
+export declare const SS_UNSTABLE_STAGE_ENDPOINTS: string[];
+export declare const SS_STABLE_STAGE_ENDPOINTS: string[];

package/dist/constants.js

@@ -1 +1,5 @@
-export const SS_ENDPOINTS = ['wss://pop-testnet.parity-lab.parity.io:443/9910'];
+export const SS_UNSTABLE_STAGE_ENDPOINTS = ['wss://pop-testnet.parity-lab.parity.io:443/9910'];
+export const SS_STABLE_STAGE_ENDPOINTS = [
+    'wss://pop3-testnet.parity-lab.parity.io:443/7911',
+    'wss://pop3-testnet.parity-lab.parity.io:443/7912',
+];

package/dist/crypto.d.ts

@@ -0,0 +1,29 @@
+import type { Codec } from 'scale-ts';
+import type { Branded } from './types.js';
+export type SsPublicKey = Branded<Uint8Array, 'SsPublicKey'>;
+export type SsSecret = Branded<Uint8Array, 'SsSecret'>;
+export type EncrPublicKey = Branded<Uint8Array, 'EncrPublicKey'>;
+export type EncrSecret = Branded<Uint8Array, 'EncrSecret'>;
+export type SharedSecret = Branded<Uint8Array, 'SharedSecret'>;
+export type SharedSession = Branded<Uint8Array, 'SharedSession'>;
+export declare function BrandedBytesCodec<T extends Uint8Array>(length?: number): Codec<T>;
+export declare const SsPubKey: Codec<SsPublicKey>;
+export declare const EncrPubKey: Codec<EncrPublicKey>;
+export declare function stringToBytes(str: string): Uint8Array<ArrayBuffer>;
+export declare function bytesToString(bytes: Uint8Array): string;
+export declare function createSsSecret(mnemonic: string): SsSecret;
+export declare function createSsDerivation(secret: SsSecret, derivation: string): SsSecret;
+export declare function getSsPub(secret: SsSecret): SsPublicKey;
+export declare function signWithSsSecret(secret: SsSecret, message: Uint8Array): Uint8Array<ArrayBufferLike>;
+export declare function verifyWithSsSecret(message: Uint8Array, signature: Uint8Array, publicKey: Uint8Array): boolean;
+export type DerivedSr25519Account = {
+    secret: SsSecret;
+    publicKey: SsPublicKey;
+    entropy: Uint8Array;
+    sign(message: Uint8Array): Uint8Array;
+    verify(message: Uint8Array, signature: Uint8Array): boolean;
+};
+export declare function deriveSr25519Account(mnemonic: string, derivation: string): DerivedSr25519Account;
+export declare function createEncrSecret(mnemonic: string): EncrSecret;
+export declare function getEncrPub(secret: EncrSecret): EncrPublicKey;
+export declare function createSharedSecret(secret: EncrSecret, publicKey: Uint8Array): SharedSecret;

package/dist/crypto.js

@@ -0,0 +1,86 @@
+import { p256 } from '@noble/curves/nist.js';
+import { mnemonicToEntropy, mnemonicToMiniSecret } from '@polkadot-labs/hdkd-helpers';
+import { HDKD as sr25519HDKD, getPublicKey as sr25519GetPublicKey, secretFromSeed as sr25519SecretFromSeed, sign as sr25519Sign, verify as sr25519Verify, } from '@scure/sr25519';
+import { Bytes, str } from 'scale-ts';
+// schemas
+export function BrandedBytesCodec(length) {
+    return Bytes(length);
+}
+export const SsPubKey = BrandedBytesCodec(32);
+export const EncrPubKey = BrandedBytesCodec(65);
+// helpers
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+export function stringToBytes(str) {
+    return textEncoder.encode(str);
+}
+export function bytesToString(bytes) {
+    return textDecoder.decode(bytes);
+}
+function parseDerivations(derivationsStr) {
+    const DERIVATION_RE = /(\/{1,2})([^/]+)/g;
+    const derivations = [];
+    for (const [, type, code] of derivationsStr.matchAll(DERIVATION_RE)) {
+        if (code) {
+            derivations.push([type === '//' ? 'hard' : 'soft', code]);
+        }
+    }
+    return derivations;
+}
+function createChainCode(derivation) {
+    const chainCode = new Uint8Array(32);
+    chainCode.set(str.enc(derivation));
+    return chainCode;
+}
+// statement store key pair
+export function createSsSecret(mnemonic) {
+    const miniSecret = mnemonicToMiniSecret(mnemonic);
+    return sr25519SecretFromSeed(miniSecret);
+}
+export function createSsDerivation(secret, derivation) {
+    const derivations = parseDerivations(derivation);
+    return derivations.reduce((secret, [type, derivation]) => {
+        const chainCode = createChainCode(derivation);
+        switch (type) {
+            case 'hard':
+                return sr25519HDKD.secretHard(secret, chainCode);
+            case 'soft':
+                return sr25519HDKD.secretSoft(secret, chainCode);
+        }
+    }, secret);
+}
+export function getSsPub(secret) {
+    return sr25519GetPublicKey(secret);
+}
+export function signWithSsSecret(secret, message) {
+    return sr25519Sign(secret, message);
+}
+export function verifyWithSsSecret(message, signature, publicKey) {
+    return sr25519Verify(message, signature, publicKey);
+}
+export function deriveSr25519Account(mnemonic, derivation) {
+    const secret = createSsDerivation(createSsSecret(mnemonic), derivation);
+    const publicKey = getSsPub(secret);
+    return {
+        secret,
+        publicKey,
+        entropy: mnemonicToEntropy(mnemonic),
+        sign: message => signWithSsSecret(secret, message),
+        verify: (message, signature) => verifyWithSsSecret(message, signature, publicKey),
+    };
+}
+// encryption key pair
+export function createEncrSecret(mnemonic) {
+    const miniSecret = mnemonicToMiniSecret(mnemonic);
+    const seed = new Uint8Array(48);
+    seed.set(miniSecret);
+    const { secretKey } = p256.keygen(seed);
+    return secretKey;
+}
+export function getEncrPub(secret) {
+    return p256.getPublicKey(secret, false);
+}
+export function createSharedSecret(secret, publicKey) {
+    // slicing first byte: @noble/curves adds y offset at the start
+    return p256.getSharedSecret(secret, publicKey).slice(1, 33);
+}

package/dist/helpers/abortError.d.ts

@@ -0,0 +1,4 @@
+export declare class AbortError extends Error {
+    constructor(message?: string);
+    static isAbortError(err: unknown): err is AbortError;
+}

package/dist/helpers/abortError.js

@@ -0,0 +1,8 @@
+export class AbortError extends Error {
+    constructor(message) {
+        super(message);
+    }
+    static isAbortError(err) {
+        return err instanceof AbortError;
+    }
+}

package/dist/helpers/callbackRaceResolver.d.ts

@@ -0,0 +1 @@
+export declare function callbackRaceResolver<T, R>(callback: (value: R) => unknown, preprocess: (value: T) => PromiseLike<R>): (value: T) => unknown;

package/dist/helpers/callbackRaceResolver.js

@@ -0,0 +1,17 @@
+export function callbackRaceResolver(callback, preprocess) {
+    let abort = new AbortController();
+    return async (value) => {
+        abort.abort();
+        abort = new AbortController();
+        try {
+            const result = await preprocess(value);
+            if (abort.signal.aborted) {
+                return;
+            }
+            callback(result);
+        }
+        catch {
+            /* empty */
+        }
+    };
+}

package/dist/helpers/result.d.ts

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,15 @@
+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

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