@indietabletop/appkit 6.1.6 → 7.0.0-0

package/dist/groupBy.d.ts

@@ -0,0 +1 @@
+export declare function groupBy<T, K extends string>(items: T[], getKey: (item: T) => K): Record<K, T[]>;

package/dist/groupBy.test.d.ts

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

package/dist/hrefs.d.ts

@@ -0,0 +1,32 @@
+import { LinkUtmParams, createUtm } from './utm.ts';
+type InputAppHrefs = {
+    login: () => string;
+    password: () => string;
+    join: () => string;
+    dashboard: () => string;
+    account: () => string;
+    terms?: (linkUtm?: LinkUtmParams) => string;
+    privacy?: (linkUtm?: LinkUtmParams) => string;
+    cookies?: (linkUtm?: LinkUtmParams) => string;
+};
+export type AppHrefs = Required<InputAppHrefs>;
+export declare function createHrefs<T extends InputAppHrefs>(params: {
+    /**
+     * Hrefs to be used for the given app. At minimum, you need to provide
+     * the core hrefs required by Appkit.
+     */
+    hrefs: T;
+    /**
+     * The function responsible for generating UTM tags. You should
+     * use the return value of {@link createUtm} unless you are doing something
+     * unusual.
+     */
+    utm: ReturnType<typeof createUtm>;
+}): {
+    terms: (linkUtm?: LinkUtmParams) => string;
+    privacy: (linkUtm?: LinkUtmParams) => string;
+    cookies: (linkUtm?: LinkUtmParams) => string;
+    itc: (linkUtm?: LinkUtmParams) => string;
+    fathom: () => string;
+} & T;
+export {};

package/dist/hrefs.test.d.ts

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

package/dist/idToDate.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Given an doc id like `2025-01-01-some-name`, will return a date matching
+ * the starting portion of the id.
+ */
+export declare function idToDate(id: string, fallback: () => Date): Date;

package/dist/idToDate.test.d.ts

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

package/dist/ids.d.ts

@@ -0,0 +1 @@
+export declare const getId: (size?: number) => string;

package/dist/ids.test.d.ts

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

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+export * from './account/CurrentUserFetcher.tsx';
+export * from './account/JoinCard.tsx';
+export * from './account/LoginCard.tsx';
+export * from './account/PasswordResetCard.tsx';
+export * from './AppConfig/AppConfig.tsx';
+export * from './AuthCard/AuthCard.tsx';
+export * from './DialogTrigger/index.tsx';
+export * from './DocumentTitle/DocumentTitle.tsx';
+export * from './ExternalLink.tsx';
+export * from './form/FormSubmitButton.tsx';
+export * from './form/SubmitErrorAlert.tsx';
+export * from './FullscreenDismissBlocker.tsx';
+export * from './IndieTabletopClubLogo.tsx';
+export * from './IndieTabletopClubSymbol.tsx';
+export * from './Letterhead/index.tsx';
+export * from './LetterheadForm/index.tsx';
+export * from './LoadingIndicator.tsx';
+export * from './MiddotSeparated/MiddotSeparated.tsx';
+export * from './ModalDialog/index.tsx';
+export * from './QRCode/QRCode.tsx';
+export * from './ReleaseInfo/index.tsx';
+export * from './SafariCheck/SafariCheck.tsx';
+export * from './ServiceWorkerHandler.tsx';
+export * from './ShareButton/ShareButton.tsx';
+export * from './SubscribeCard/SubscribeByEmailCard.tsx';
+export * from './SubscribeCard/SubscribeByPledgeCard.tsx';
+export * from './RulesetResolver.ts';
+export * from './use-async-op.ts';
+export * from './use-document-background-color.ts';
+export * from './use-form.ts';
+export * from './use-is-installed.ts';
+export * from './use-media-query.ts';
+export * from './use-reverting-state.ts';
+export * from './use-scroll-restoration.ts';
+export * from './useEnsureValue.ts';
+export * from './useInvokeClient.ts';
+export * from './useIsVisible.ts';
+export * from './append-copy-to-text.ts';
+export * from './async-op.ts';
+export * from './caught-value.ts';
+export * from './class-names.ts';
+export * from './client.ts';
+export * from './copyrightRange.ts';
+export * from './createSafeStorage.ts';
+export * from './failureMessages.ts';
+export * from './groupBy.ts';
+export * from './HistoryState.ts';
+export * from './hrefs.ts';
+export * from './ids.ts';
+export * from './idToDate.ts';
+export * from './mailto.ts';
+export * from './media.ts';
+export * from './random.ts';
+export * from './result/swr.ts';
+export * from './sleep.ts';
+export * from './structs.ts';
+export * from './typeguards.ts';
+export * from './types.ts';
+export * from './unique.ts';
+export * from './utm.ts';
+export * from './validations.ts';
+export * from './EnumMapper.ts';
+export * from './ModernIDB/index.ts';
+export * from './store/index.tsx';

package/dist/internal.css.d.ts

@@ -0,0 +1,2 @@
+export declare const animationDelay: `var(--${string})`;
+export declare const dot: string;

package/dist/mailto.d.ts

@@ -0,0 +1,8 @@
+type MailtoPayload = {
+    body?: string | null;
+    subject?: string | null;
+    cc?: string | string[] | null;
+    bcc?: string | string[] | null;
+};
+export declare function mailto(recipient: string | null, payload?: MailtoPayload): string;
+export {};

package/dist/mailto.test.d.ts

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

package/dist/media.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme
+ */
+export declare enum PrefersColorScheme {
+    LIGHT = "(prefers-color-scheme: light)",
+    DARK = "(prefers-color-scheme: dark)"
+}
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-reduced-motion
+ */
+export declare enum PrefersReducedMotion {
+    NO_PREFERENCE = "(prefers-reduced-motion: no-preference)",
+    REDUCE = "(prefers-reduced-motion: reduce)"
+}
+export declare enum Hover {
+    NONE = "(hover: none)",
+    HOVER = "(hover: hover) and (pointer: fine)"
+}
+export declare enum MediaType {
+    PRINT = "print",
+    SCREEN = "screen"
+}
+export declare enum MinHeight {
+    TALL = "(min-height: 40em)"
+}
+export declare enum MinWidth {
+    SMALL = "(min-width: 28em)",
+    MEDIUM = "(min-width: 50em)",
+    WIDE = "(min-width: 66em)",
+    X_WIDE = "(min-width: 80em)",
+    XX_WIDE = "(min-width: 140em)"
+}
+export declare enum DisplayMode {
+    STANDALONE = "(display-mode: standalone)"
+}
+export declare enum Pointer {
+    COARSE = "(pointer: coarse)",
+    FINE = "(pointer: fine)"
+}

package/dist/random.d.ts

@@ -0,0 +1,3 @@
+export declare function random(max: number): number;
+export declare function randomItem<T>(array: T[]): T;
+export declare function randomItemOrThrow<T>(array: T[]): NonNullable<T>;

package/dist/result/swr.d.ts

@@ -0,0 +1,4 @@
+import { SWRResponse } from 'swr';
+import { Failure, Pending } from '../async-op.ts';
+import { FailurePayload } from '../types.ts';
+export declare function swrResponseToResult<T>(response: SWRResponse<T, unknown>): Pending | Failure<FailurePayload> | (T & ({} | null));

package/{lib/sleep.ts → dist/sleep.d.ts}

@@ -9,6 +9,4 @@
  * await sleep(2000) // Waits for 2s
  * ```
  */
-export function sleep(ms: number) {
-  return new Promise((r) => setTimeout(r, ms));
-}
+export declare function sleep(ms: number): Promise<unknown>;

package/dist/store/index.d.ts

@@ -0,0 +1,237 @@
+import { UserGameData } from '@indietabletop/types';
+import { ReactNode } from 'react';
+import { Failure, Success } from '../async-op.ts';
+import { GameCode, IndieTabletopClient } from '../client.ts';
+import { ModernIDB } from '../ModernIDB/ModernIDB.ts';
+import { ModernIDBIndexes, ModernIDBSchema } from '../ModernIDB/types.ts';
+import { CurrentUser } from '../types.ts';
+import { PullChangesInput, PushChangesInput } from './store.ts';
+import { MachineEvent, PullResult, PushResult } from './types.ts';
+export type AppActions = {
+    clientLogout: (params: {
+        serverUser: CurrentUser;
+    }) => Promise<void>;
+    serverLogout: () => Promise<void>;
+    logout: () => Promise<void>;
+    push: () => void;
+    pull: () => void;
+};
+export declare const AppActionsContext: import('react').Context<AppActions | null>;
+declare const useSelector: <T>(selector: (snapshot: import('xstate').MachineSnapshot<import('./types.ts').MachineContext, {
+    type: "push";
+} | {
+    type: "pull";
+} | {
+    type: "currentUser";
+    currentUser: CurrentUser;
+} | {
+    type: "serverUser";
+    serverUser: CurrentUser;
+} | {
+    type: "sessionInfo";
+    sessionInfo: import('../types.ts').SessionInfo;
+} | {
+    type: "sessionExpired";
+} | {
+    type: "reset";
+}, {
+    [x: string]: import('xstate').ActorRefFromLogic<import('xstate').CallbackActorLogic<MachineEvent, import('xstate').NonReducibleUnknown, import('xstate').EventObject>> | import('xstate').ActorRefFromLogic<import('xstate').PromiseActorLogic<PullResult, PullChangesInput, import('xstate').EventObject>> | import('xstate').ActorRefFromLogic<import('xstate').PromiseActorLogic<PushResult, PushChangesInput, import('xstate').EventObject>> | undefined;
+    sync?: import('xstate').ActorRefFromLogic<import('xstate').CallbackActorLogic<MachineEvent, import('xstate').NonReducibleUnknown, import('xstate').EventObject>> | undefined;
+    auth?: import('xstate').ActorRefFromLogic<import('xstate').CallbackActorLogic<MachineEvent, import('xstate').NonReducibleUnknown, import('xstate').EventObject>> | undefined;
+}, "unauthenticated" | {
+    authenticated: "ineligible" | {
+        sync: "idle" | "waiting" | {
+            syncing: "pulling" | "pushing" | "failed" | "synced";
+        };
+    };
+}, string, import('xstate').NonReducibleUnknown, import('xstate').MetaObject, {
+    id: "app";
+    states: {
+        readonly unauthenticated: {};
+        readonly authenticated: {
+            states: {
+                readonly ineligible: {};
+                readonly sync: {
+                    states: {
+                        readonly syncing: {
+                            states: {
+                                readonly pulling: {};
+                                readonly pushing: {};
+                                readonly synced: {};
+                                readonly failed: {};
+                            };
+                        };
+                        readonly idle: {};
+                        readonly waiting: {};
+                    };
+                };
+            };
+        };
+    };
+}>) => T, compare?: ((a: T, b: T) => boolean) | undefined) => T, useActorRef: () => import('xstate').Actor<import('xstate').StateMachine<import('./types.ts').MachineContext, {
+    type: "push";
+} | {
+    type: "pull";
+} | {
+    type: "currentUser";
+    currentUser: CurrentUser;
+} | {
+    type: "serverUser";
+    serverUser: CurrentUser;
+} | {
+    type: "sessionInfo";
+    sessionInfo: import('../types.ts').SessionInfo;
+} | {
+    type: "sessionExpired";
+} | {
+    type: "reset";
+}, {
+    [x: string]: import('xstate').ActorRefFromLogic<import('xstate').CallbackActorLogic<MachineEvent, import('xstate').NonReducibleUnknown, import('xstate').EventObject>> | import('xstate').ActorRefFromLogic<import('xstate').PromiseActorLogic<PullResult, PullChangesInput, import('xstate').EventObject>> | import('xstate').ActorRefFromLogic<import('xstate').PromiseActorLogic<PushResult, PushChangesInput, import('xstate').EventObject>> | undefined;
+    sync?: import('xstate').ActorRefFromLogic<import('xstate').CallbackActorLogic<MachineEvent, import('xstate').NonReducibleUnknown, import('xstate').EventObject>> | undefined;
+    auth?: import('xstate').ActorRefFromLogic<import('xstate').CallbackActorLogic<MachineEvent, import('xstate').NonReducibleUnknown, import('xstate').EventObject>> | undefined;
+}, {
+    src: "sync";
+    logic: import('xstate').CallbackActorLogic<MachineEvent, import('xstate').NonReducibleUnknown, import('xstate').EventObject>;
+    id: "sync";
+} | {
+    src: "auth";
+    logic: import('xstate').CallbackActorLogic<MachineEvent, import('xstate').NonReducibleUnknown, import('xstate').EventObject>;
+    id: "auth";
+} | {
+    src: "pullChanges";
+    logic: import('xstate').PromiseActorLogic<PullResult, PullChangesInput, import('xstate').EventObject>;
+    id: string | undefined;
+} | {
+    src: "pushChanges";
+    logic: import('xstate').PromiseActorLogic<PushResult, PushChangesInput, import('xstate').EventObject>;
+    id: string | undefined;
+}, {
+    type: "setCurrentSync";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "flushCurrentSync";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "setLastSuccessfulSync";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "markSyncStepResult";
+    params: {
+        pull?: PullResult;
+        push?: PushResult;
+    };
+} | {
+    type: "queuePush";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "clearPushQueue";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "setCurrentUser";
+    params: {
+        id: string;
+        email: string;
+        isVerified: boolean;
+        prefersScrollbarVisibility?: "ALWAYS" | undefined;
+    };
+} | {
+    type: "patchSessionInfo";
+    params: {
+        createdTs: number;
+        expiresTs: number;
+    };
+} | {
+    type: "resetContext";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "resetWithServerUser";
+    params: {
+        id: string;
+        email: string;
+        isVerified: boolean;
+        prefersScrollbarVisibility?: "ALWAYS" | undefined;
+    };
+}, {
+    type: "shouldPushOnceIdle";
+    params: unknown;
+} | {
+    type: "isEligibleForSync";
+    params: unknown;
+} | {
+    type: "isUserVerified";
+    params: unknown;
+} | {
+    type: "isNotMismatched";
+    params: unknown;
+} | {
+    type: "hasBecomeEligibleForSync";
+    params: unknown;
+} | {
+    type: "hasBecomeVerified";
+    params: unknown;
+}, never, "unauthenticated" | {
+    authenticated: "ineligible" | {
+        sync: "idle" | "waiting" | {
+            syncing: "pulling" | "pushing" | "failed" | "synced";
+        };
+    };
+}, string, import('xstate').NonReducibleUnknown, import('xstate').NonReducibleUnknown, import('xstate').EventObject, import('xstate').MetaObject, {
+    id: "app";
+    states: {
+        readonly unauthenticated: {};
+        readonly authenticated: {
+            states: {
+                readonly ineligible: {};
+                readonly sync: {
+                    states: {
+                        readonly syncing: {
+                            states: {
+                                readonly pulling: {};
+                                readonly pushing: {};
+                                readonly synced: {};
+                                readonly failed: {};
+                            };
+                        };
+                        readonly idle: {};
+                        readonly waiting: {};
+                    };
+                };
+            };
+        };
+    };
+}>>;
+export { useActorRef, useSelector };
+export declare function useCurrentUser(): {
+    id: string;
+    email: string;
+    isVerified: boolean;
+    prefersScrollbarVisibility?: "ALWAYS" | undefined;
+} | null;
+export declare function useSessionInfo(): {
+    createdTs: number;
+    expiresTs: number;
+} | null;
+export declare function useAppActions(): AppActions;
+export type DatabaseAppMachineMethods = {
+    upsertGameData(data: UserGameData): Promise<Success<string[]>>;
+    getUpdatedGameDataSince(props: {
+        sinceTs: number | null;
+        exclude: Set<string>;
+    }): Promise<Success<UserGameData>>;
+    clearAll(): Promise<Success<string> | Failure<string>>;
+};
+export declare function createAppMachineProvider<Schema extends ModernIDBSchema, Indexes extends ModernIDBIndexes<Schema>>(options: {
+    database: ModernIDB<Schema, Indexes> & DatabaseAppMachineMethods;
+    client: IndieTabletopClient;
+    /**
+     * Which games should the machine pull game data for?
+     *
+     * If null is provided, no data will be pulled.
+     *
+     * @remarks Honestly this is a bit hacky and we should have a better way to
+     * disable sync entirely for apps that don't need it (e.g. the Creators App).
+     */
+    pullGameDataFor: GameCode | GameCode[] | null;
+}): (props: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/store/store.d.ts

@@ -0,0 +1,144 @@
+import { CurrentUser, SessionInfo } from '../types.ts';
+import { MachineContext, MachineEvent, PullResult, PushResult, SyncedItem } from './types.ts';
+export type PullChangesInput = {
+    sinceTs: number | null;
+    currentUser: CurrentUser;
+};
+export type PushChangesInput = {
+    sinceTs: number | null;
+    currentSyncTs: number;
+    ignoredItems: SyncedItem[];
+    currentUser: CurrentUser;
+};
+export declare const machine: import('xstate').StateMachine<MachineContext, {
+    type: "push";
+} | {
+    type: "pull";
+} | {
+    type: "currentUser";
+    currentUser: CurrentUser;
+} | {
+    type: "serverUser";
+    serverUser: CurrentUser;
+} | {
+    type: "sessionInfo";
+    sessionInfo: SessionInfo;
+} | {
+    type: "sessionExpired";
+} | {
+    type: "reset";
+}, {
+    [x: string]: import('xstate').ActorRefFromLogic<import('xstate').CallbackActorLogic<MachineEvent, import('xstate').NonReducibleUnknown, import('xstate').EventObject>> | import('xstate').ActorRefFromLogic<import('xstate').PromiseActorLogic<PullResult, PullChangesInput, import('xstate').EventObject>> | import('xstate').ActorRefFromLogic<import('xstate').PromiseActorLogic<PushResult, PushChangesInput, import('xstate').EventObject>> | undefined;
+    sync?: import('xstate').ActorRefFromLogic<import('xstate').CallbackActorLogic<MachineEvent, import('xstate').NonReducibleUnknown, import('xstate').EventObject>> | undefined;
+    auth?: import('xstate').ActorRefFromLogic<import('xstate').CallbackActorLogic<MachineEvent, import('xstate').NonReducibleUnknown, import('xstate').EventObject>> | undefined;
+}, {
+    src: "sync";
+    logic: import('xstate').CallbackActorLogic<MachineEvent, import('xstate').NonReducibleUnknown, import('xstate').EventObject>;
+    id: "sync";
+} | {
+    src: "auth";
+    logic: import('xstate').CallbackActorLogic<MachineEvent, import('xstate').NonReducibleUnknown, import('xstate').EventObject>;
+    id: "auth";
+} | {
+    src: "pullChanges";
+    logic: import('xstate').PromiseActorLogic<PullResult, PullChangesInput, import('xstate').EventObject>;
+    id: string | undefined;
+} | {
+    src: "pushChanges";
+    logic: import('xstate').PromiseActorLogic<PushResult, PushChangesInput, import('xstate').EventObject>;
+    id: string | undefined;
+}, {
+    type: "setCurrentSync";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "flushCurrentSync";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "setLastSuccessfulSync";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "markSyncStepResult";
+    params: {
+        pull?: PullResult;
+        push?: PushResult;
+    };
+} | {
+    type: "queuePush";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "clearPushQueue";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "setCurrentUser";
+    params: {
+        id: string;
+        email: string;
+        isVerified: boolean;
+        prefersScrollbarVisibility?: "ALWAYS" | undefined;
+    };
+} | {
+    type: "patchSessionInfo";
+    params: {
+        createdTs: number;
+        expiresTs: number;
+    };
+} | {
+    type: "resetContext";
+    params: import('xstate').NonReducibleUnknown;
+} | {
+    type: "resetWithServerUser";
+    params: {
+        id: string;
+        email: string;
+        isVerified: boolean;
+        prefersScrollbarVisibility?: "ALWAYS" | undefined;
+    };
+}, {
+    type: "shouldPushOnceIdle";
+    params: unknown;
+} | {
+    type: "isEligibleForSync";
+    params: unknown;
+} | {
+    type: "isUserVerified";
+    params: unknown;
+} | {
+    type: "isNotMismatched";
+    params: unknown;
+} | {
+    type: "hasBecomeEligibleForSync";
+    params: unknown;
+} | {
+    type: "hasBecomeVerified";
+    params: unknown;
+}, never, "unauthenticated" | {
+    authenticated: "ineligible" | {
+        sync: "idle" | "waiting" | {
+            syncing: "pulling" | "pushing" | "failed" | "synced";
+        };
+    };
+}, string, import('xstate').NonReducibleUnknown, import('xstate').NonReducibleUnknown, import('xstate').EventObject, import('xstate').MetaObject, {
+    id: "app";
+    states: {
+        readonly unauthenticated: {};
+        readonly authenticated: {
+            states: {
+                readonly ineligible: {};
+                readonly sync: {
+                    states: {
+                        readonly syncing: {
+                            states: {
+                                readonly pulling: {};
+                                readonly pushing: {};
+                                readonly synced: {};
+                                readonly failed: {};
+                            };
+                        };
+                        readonly idle: {};
+                        readonly waiting: {};
+                    };
+                };
+            };
+        };
+    };
+}>;

package/dist/store/types.d.ts

@@ -0,0 +1,49 @@
+import { Failure, Success } from '../async-op.ts';
+import { CurrentUser, FailurePayload, SessionInfo } from '../types.ts';
+export type EmitterActor<Outgoing> = {
+    sendBack: (event: Outgoing) => void;
+};
+export type PullResult = Success<{
+    pulled: SyncedItem[];
+}> | Failure<FailurePayload>;
+export type PushResult = Success<{
+    pushed: SyncedItem[];
+    pulled: SyncedItem[];
+}> | Failure<FailurePayload>;
+export type SyncedItem = {
+    id: string;
+    name: string;
+    updatedTs: number;
+    deleted: boolean;
+};
+export type SyncAttempt = {
+    startedTs: number;
+    pull: PullResult | null;
+    push: PushResult | null;
+};
+export type MachineContext = {
+    currentSync: SyncAttempt | null;
+    lastSuccessfulSyncTs: number | null;
+    currentUser: CurrentUser | null;
+    sessionInfo: SessionInfo | null;
+    pushOnceIdle: boolean;
+    syncLog: SyncAttempt[];
+};
+export type MachineEvent = {
+    type: "push";
+} | {
+    type: "pull";
+} | {
+    type: "currentUser";
+    currentUser: CurrentUser;
+} | {
+    type: "serverUser";
+    serverUser: CurrentUser;
+} | {
+    type: "sessionInfo";
+    sessionInfo: SessionInfo;
+} | {
+    type: "sessionExpired";
+} | {
+    type: "reset";
+};

package/dist/store/utils.d.ts

@@ -0,0 +1,10 @@
+import { UserGameData } from '@indietabletop/types';
+import { Failure } from '../async-op.js';
+import { FailurePayload } from '../types.ts';
+import { SyncedItem } from './types.ts';
+/**
+ * Flattens the UserGameData structure to a flat SyncedItem[].
+ */
+export declare function toSyncedItems(data: UserGameData): SyncedItem[];
+export declare function assertNonNullish<T>(value: T, message: string): asserts value is NonNullable<T>;
+export declare function caughtToResult(error: unknown): Failure<FailurePayload>;

package/dist/storybook/decorators.d.ts

@@ -0,0 +1,3 @@
+import { FormProviderProps } from '@ariakit/react';
+import { Decorator } from '@storybook/react-vite';
+export declare function form(props?: FormProviderProps): Decorator;

package/dist/structs.d.ts

@@ -0,0 +1 @@
+export { currentUser, redeemedPledge, sessionInfo } from '@indietabletop/types';

package/{lib/typeguards.ts → dist/typeguards.d.ts}

@@ -7,6 +7,4 @@
  * This function uses the same semantics like the nullish coalescing operators
  * like `??` and `??=`.
  */
-export function isNullish(value: unknown): value is null | undefined {
-  return value === null || value === undefined;
-}
+export declare function isNullish(value: unknown): value is null | undefined;

package/dist/typeguards.test.d.ts

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