@indietabletop/appkit 3.2.0-0 → 3.2.0-10

package/dist/ServiceWorkerHandler.js

@@ -1,42 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { useEffect } from "react";
-/**
- * This component handles the installation of a service worker.
- *
- * Currently it doesn't do much, but, eventually, it should provide context
- * to nested components communicating the status of the service worker installation.
- */
-export function ServiceWorkerHandler(props) {
-    useEffect(() => {
-        async function registerWorker() {
-            // Although modern browsers all support service workers, native app's
-            // web views (eg. the Facebook app's embedded browsers) do not.
-            if ("serviceWorker" in navigator) {
-                try {
-                    const registration = await navigator.serviceWorker.register(props.path);
-                    console.info("Service worker registration obtained.");
-                    registration.addEventListener("updatefound", () => {
-                        const worker = registration.installing;
-                        console.info("Installing new service worker.");
-                        worker?.addEventListener("statechange", ({ target }) => {
-                            if (target instanceof ServiceWorker) {
-                                console.info(`Service worker state changed: '${target.state}'.`);
-                            }
-                        });
-                    });
-                }
-                catch (error) {
-                    // In rare cases, service worker installation can fail, e.g. due to network
-                    // connectivity. There is no need to report the error as there is nothing
-                    // that can be done to prevent this from occassionally happening.
-                    console.error(error);
-                }
-            }
-        }
-        void registerWorker();
-        // Note that it is not necessary to 'cleanup' the registration in
-        // the useEffect hook. Calling register() multiple times is a no-op.
-        // See https://web.dev/articles/service-workers-registration#subsequent_visits
-    }, [props.path]);
-    return _jsx(_Fragment, { children: props.children });
-}

package/dist/animations.css.d.ts

@@ -1,3 +0,0 @@
-export declare const fadeIn: string;
-export declare const slideUp: string;
-export declare const bounce: string;

package/dist/animations.css.js

@@ -1,14 +0,0 @@
-import { keyframes } from "@vanilla-extract/css";
-export const fadeIn = keyframes({
-    from: { opacity: 0 },
-    to: { opacity: 1 },
-});
-export const slideUp = keyframes({
-    from: { transform: `translateY(100%)` },
-    to: { transform: `translateY(0)` },
-});
-export const bounce = keyframes({
-    "0%": { transform: "translateY(0)" },
-    "20%": { transform: "translateY(-20%)" },
-    "50%": { transform: "translateY(0)" },
-});

package/dist/append-copy-to-text.d.ts

@@ -1,10 +0,0 @@
-/**
- * Appends " (Copy)" to the end of the input string if it doesn't already end
- * with " (Copy)", otherwise it appends a number after "Copy", incrementing it
- * if necessary.
- */
-export declare function appendCopyToText(input: string): string;
-/**
- * Works like {@link appendCopyToText}, but ignores empty strings.
- */
-export declare function maybeAppendCopyToText(input: string): string;

package/dist/append-copy-to-text.js

@@ -1,29 +0,0 @@
-/**
- * Appends " (Copy)" to the end of the input string if it doesn't already end
- * with " (Copy)", otherwise it appends a number after "Copy", incrementing it
- * if necessary.
- */
-export function appendCopyToText(input) {
-    const regex = /^(?<value>.*) \(Copy(?: (?<count>\d+))?\)$/;
-    const match = input.match(regex);
-    // If there isn't a match, we directly append to the input.
-    if (!match) {
-        return `${input.trim()} (Copy)`;
-    }
-    const { value, count } = match.groups ?? {};
-    // If `count` capturing group is not present, it means that the input ends
-    // with the copy suffix, but it doesn't contain count.
-    const nextCount = !count ? 2 : parseInt(count, 10) + 1;
-    return `${value.trim()} (Copy ${nextCount})`;
-}
-/**
- * Works like {@link appendCopyToText}, but ignores empty strings.
- */
-export function maybeAppendCopyToText(input) {
-    // If input is falsy (i.e. empty string) then we don't want to append
-    // anything to it.
-    if (!input) {
-        return "";
-    }
-    return appendCopyToText(input);
-}

package/dist/async-op.d.ts

@@ -1,87 +0,0 @@
-type Falsy = null | undefined | false | 0 | 0n | "";
-type Truthy<T> = Exclude<T, Falsy>;
-interface Operation<SuccessValue, FailureValue> {
-    readonly type: "SUCCESS" | "FAILURE" | "PENDING";
-    readonly isPending: boolean;
-    readonly isSuccess: boolean;
-    readonly isFailure: boolean;
-    val: SuccessValue | FailureValue | null;
-    valueOrNull(): SuccessValue | null;
-    valueOrThrow(): SuccessValue;
-    hasTruthyValue(): boolean;
-    failureValueOrNull(): FailureValue | null;
-    failureValueOrThrow(): FailureValue;
-    flatMap<T extends AsyncOp<unknown, unknown>>(mappingFn: (value: SuccessValue) => T): T | Failure<FailureValue> | Pending;
-    mapSuccess<MappedSuccess>(mappingFn: (value: SuccessValue) => MappedSuccess): Operation<MappedSuccess, FailureValue>;
-    mapFailure<MappedFailure>(mappingFn: (value: FailureValue) => MappedFailure): Operation<SuccessValue, MappedFailure>;
-    unpack<S, F, P>(mapS: (value: SuccessValue) => S, mapF: (failure: FailureValue) => F, mapP: () => P): S | F | P;
-}
-export declare class Pending implements Operation<never, never> {
-    readonly type: "PENDING";
-    readonly isPending: true;
-    readonly isSuccess: false;
-    readonly isFailure: false;
-    val: null;
-    valueOrNull(): null;
-    valueOrThrow(): never;
-    hasTruthyValue(): false;
-    failureValueOrNull(): null;
-    failureValueOrThrow(): never;
-    flatMap(): Pending;
-    mapSuccess(): Pending;
-    mapFailure(): Pending;
-    unpack<S, F, P>(_mapS: (value: never) => S, _mapF: (failure: never) => F, mapP: () => P): S | F | P;
-}
-export declare class Success<SuccessValue> implements Operation<SuccessValue, never> {
-    readonly type: "SUCCESS";
-    readonly isPending: false;
-    readonly isSuccess: true;
-    readonly isFailure: false;
-    readonly value: SuccessValue;
-    readonly val: SuccessValue;
-    constructor(value: SuccessValue);
-    valueOrNull(): SuccessValue;
-    valueOrThrow(): SuccessValue;
-    hasTruthyValue(): this is Success<Truthy<SuccessValue>>;
-    failureValueOrNull(): null;
-    failureValueOrThrow(): never;
-    flatMap<T extends AsyncOp<unknown, unknown>>(mappingFn: (value: SuccessValue) => T): T;
-    mapSuccess<MappedValue>(mappingFn: (value: SuccessValue) => MappedValue): Success<MappedValue>;
-    mapFailure(): Success<SuccessValue>;
-    unpack<S, F, P>(mapS: (value: SuccessValue) => S, _mapF: (failure: never) => F, _mapP: () => P): S | F | P;
-}
-export declare class Failure<FailureValue> implements Operation<never, FailureValue> {
-    readonly type: "FAILURE";
-    readonly isPending: false;
-    readonly isSuccess: false;
-    readonly isFailure: true;
-    readonly failure: FailureValue;
-    readonly val: FailureValue;
-    constructor(failure: FailureValue);
-    valueOrNull(): null;
-    valueOrThrow(): never;
-    hasTruthyValue(): false;
-    failureValueOrNull(): FailureValue;
-    failureValueOrThrow(): FailureValue;
-    flatMap(): Failure<FailureValue>;
-    mapSuccess(): Failure<FailureValue>;
-    mapFailure<MappedFailure>(mappingFn: (value: FailureValue) => MappedFailure): Failure<MappedFailure>;
-    unpack<S, F, P>(_mapS: (value: never) => S, mapF: (failure: FailureValue) => F, _mapP: () => P): S | F | P;
-}
-/**
- * Folds multiple ops into a single op.
- *
- * To return a Success, all ops provided must be a Success. If any Failures are
- * encountered, will return the first one found.
- *
- * If neither of these conditions is true, will return Pending.
- *
- * Note that if passed an empty array, will always return a Success (with an
- * empty array as value). This mimics the semantics of many JS constructs, like
- * Promise.all or Array.prototype.every.
- */
-export declare function fold<Ops extends readonly AsyncOp<unknown, unknown>[] | []>(ops: Ops): AsyncOp<{
-    -readonly [Index in keyof Ops]: Ops[Index] extends AsyncOp<infer S, unknown> ? S : never;
-}, Ops[number] extends AsyncOp<unknown, infer F> ? F : never>;
-export type AsyncOp<SuccessValue, FailureValue> = Pending | Success<SuccessValue> | Failure<FailureValue>;
-export {};

package/dist/async-op.js

@@ -1,223 +0,0 @@
-export class Pending {
-    constructor() {
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "PENDING"
-        });
-        Object.defineProperty(this, "isPending", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "isSuccess", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "isFailure", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "val", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: null
-        });
-    }
-    valueOrNull() {
-        return null;
-    }
-    valueOrThrow() {
-        throw new Error(`AsyncOp value was accessed but the op is in Pending state.`);
-    }
-    hasTruthyValue() {
-        return false;
-    }
-    failureValueOrNull() {
-        return null;
-    }
-    failureValueOrThrow() {
-        throw new Error(`AsyncOp failure value was accessed but the op is in Pending state.`);
-    }
-    flatMap() {
-        return new Pending();
-    }
-    mapSuccess() {
-        return new Pending();
-    }
-    mapFailure() {
-        return new Pending();
-    }
-    unpack(_mapS, _mapF, mapP) {
-        return mapP();
-    }
-}
-export class Success {
-    constructor(value) {
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "SUCCESS"
-        });
-        Object.defineProperty(this, "isPending", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "isSuccess", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "isFailure", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "value", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "val", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.value = value;
-        this.val = value;
-    }
-    valueOrNull() {
-        return this.value;
-    }
-    valueOrThrow() {
-        return this.value;
-    }
-    hasTruthyValue() {
-        return !!this.value;
-    }
-    failureValueOrNull() {
-        return null;
-    }
-    failureValueOrThrow() {
-        throw new Error(`AsyncOp failure value was accessed but the op is in Success state.`);
-    }
-    flatMap(mappingFn) {
-        return mappingFn(this.value);
-    }
-    mapSuccess(mappingFn) {
-        return new Success(mappingFn(this.value));
-    }
-    mapFailure() {
-        return new Success(this.value);
-    }
-    unpack(mapS, _mapF, _mapP) {
-        return mapS(this.value);
-    }
-}
-export class Failure {
-    constructor(failure) {
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "FAILURE"
-        });
-        Object.defineProperty(this, "isPending", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "isSuccess", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "isFailure", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "failure", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "val", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.failure = failure;
-        this.val = failure;
-    }
-    valueOrNull() {
-        return null;
-    }
-    valueOrThrow() {
-        throw new Error(`AsyncOp value was accessed but the op is in Failure state.`);
-    }
-    hasTruthyValue() {
-        return false;
-    }
-    failureValueOrNull() {
-        return this.failure;
-    }
-    failureValueOrThrow() {
-        return this.failure;
-    }
-    flatMap() {
-        return new Failure(this.failure);
-    }
-    mapSuccess() {
-        return new Failure(this.failure);
-    }
-    mapFailure(mappingFn) {
-        return new Failure(mappingFn(this.failure));
-    }
-    unpack(_mapS, mapF, _mapP) {
-        return mapF(this.failure);
-    }
-}
-/**
- * Folds multiple ops into a single op.
- *
- * To return a Success, all ops provided must be a Success. If any Failures are
- * encountered, will return the first one found.
- *
- * If neither of these conditions is true, will return Pending.
- *
- * Note that if passed an empty array, will always return a Success (with an
- * empty array as value). This mimics the semantics of many JS constructs, like
- * Promise.all or Array.prototype.every.
- */
-export function fold(ops) {
-    // Note that due to the semantics of `every`, if the array provided to `fold`
-    // is empty, the result will be a Success with an empty array.
-    if (ops.every((v) => v.isSuccess)) {
-        return new Success(ops.map((op) => op.value));
-    }
-    const firstFail = ops.find((op) => op.isFailure);
-    if (firstFail) {
-        return firstFail;
-    }
-    return new Pending();
-}

package/dist/caught-value.d.ts

@@ -1,15 +0,0 @@
-/**
- * Safely returns a string from an unknown value.
- *
- * This function is intended to be used when handling values caught
- * in try/catch blocks.
- *
- * In JS/TS, unless errors are returned, they cannot be properly typed
- * because any code within the try block can throw. Additionally, thrown
- * values do not have to be Errors.
- *
- * This function makes sure to first assert if an Error was caught, and
- * if so, returns its message. If a string was caught, it returns that.
- * Otherwise, it returns "Unknown error".
- */
-export declare function caughtValueToString(value: unknown): string;

package/dist/class-names.d.ts

@@ -1,4 +0,0 @@
-/**
- * Combines a list of strings into a single string. Falsy values are ignored.
- */
-export declare function classNames(...classNames: (string | false | null | undefined)[]): string;

package/dist/class-names.js

@@ -1,6 +0,0 @@
-/**
- * Combines a list of strings into a single string. Falsy values are ignored.
- */
-export function classNames(...classNames) {
-    return classNames.filter((c) => !!c).join(" ");
-}

package/dist/client.d.ts

@@ -1,117 +0,0 @@
-import { Failure, Success } from "@indietabletop/appkit/async-op";
-import { type Infer, Struct } from "superstruct";
-import type { CurrentUser, FailurePayload, SessionInfo } from "./types.js";
-export declare class IndieTabletopClient {
-    origin: string;
-    private onCurrentUser?;
-    private onSessionInfo?;
-    private onSessionExpired?;
-    private refreshTokenPromise?;
-    constructor(props: {
-        apiOrigin: string;
-        /**
-         * Runs every time the current user is fetched from the API. Typically, this
-         * happens during login, signup, and when the current user is fetched.
-         */
-        onCurrentUser?: (currentUser: CurrentUser) => void;
-        /**
-         * Runs ever time new session info is fetched from the API. Typically, this
-         * happends during login, signup, and when tokens are refreshed.
-         */
-        onSessionInfo?: (sessionInfo: SessionInfo) => void;
-        /**
-         * Runs when token refresh is attempted, but fails due to 401 error.
-         */
-        onSessionExpired?: () => void;
-    });
-    protected fetch<T, S>(path: string, struct: Struct<T, S>, init?: RequestInit & {
-        json?: object;
-    }): Promise<Success<Infer<Struct<T, S>>> | Failure<FailurePayload>>;
-    /**
-     * Fetches data and retries 401 failures after attempting to refresh tokens.
-     */
-    protected fetchWithAuth<T, S>(path: string, struct: Struct<T, S>, init?: RequestInit & {
-        json?: object;
-    }): Promise<Success<Infer<Struct<T, S>>> | Failure<FailurePayload>>;
-    login(payload: {
-        email: string;
-        password: string;
-    }): Promise<Failure<FailurePayload> | Success<{
-        sessionInfo: {
-            expiresTs: number;
-            createdTs: number;
-        };
-        currentUser: {
-            id: string;
-            email: string;
-            isVerified: boolean;
-            prefersScrollbarVisibility?: "ALWAYS" | undefined;
-        };
-    }>>;
-    logout(): Promise<Failure<FailurePayload> | Success<{
-        message: string;
-    }>>;
-    join(payload: {
-        email: string;
-        password: string;
-        acceptedTos: boolean;
-        subscribedToNewsletter: boolean;
-    }): Promise<Failure<FailurePayload> | Success<{
-        sessionInfo: {
-            expiresTs: number;
-            createdTs: number;
-        };
-        currentUser: {
-            id: string;
-            email: string;
-            isVerified: boolean;
-            prefersScrollbarVisibility?: "ALWAYS" | undefined;
-        };
-        tokenId: string;
-    }>>;
-    /**
-     * Triggers token refresh process.
-     *
-     * Note that we do not want to perform multiple concurrent token refresh
-     * actions, as that will result in unnecessary 401s. For this reason, a
-     * reference to t
-     */
-    refreshTokens(): Promise<Success<{
-        sessionInfo: SessionInfo;
-    }> | Failure<FailurePayload>>;
-    requestPasswordReset(payload: {
-        email: string;
-    }): Promise<Failure<FailurePayload> | Success<{
-        message: string;
-        tokenId: string;
-    }>>;
-    checkPasswordResetCode(payload: {
-        tokenId: string;
-        code: string;
-    }): Promise<Failure<FailurePayload> | Success<{
-        message: string;
-    }>>;
-    setNewPassword(payload: {
-        tokenId: string;
-        code: string;
-        password: string;
-    }): Promise<Failure<FailurePayload> | Success<{
-        message: string;
-    }>>;
-    requestUserVerification(): Promise<Failure<FailurePayload> | Success<{
-        message: string;
-        tokenId: string;
-    }>>;
-    verifyUser(payload: {
-        tokenId: string;
-        code: string;
-    }): Promise<Failure<FailurePayload> | Success<{
-        message: string;
-    }>>;
-    getCurrentUser(): Promise<Failure<FailurePayload> | Success<{
-        id: string;
-        email: string;
-        isVerified: boolean;
-        prefersScrollbarVisibility?: "ALWAYS" | undefined;
-    }>>;
-}