@indietabletop/appkit 6.1.5 → 7.0.0-0

package/dist/RulesetResolver.d.ts

@@ -0,0 +1,87 @@
+import { Failure, Pending, Success } from './async-op.ts';
+type RulesetLike = {
+    version: string;
+};
+type GetRemoteRuleset<R extends RulesetLike, F> = (version: string) => Promise<Success<R> | Failure<F>>;
+type RulesetResolverProps<R extends RulesetLike, F> = {
+    /**
+     * The initial ruleset that will be available to all users immediately at
+     * app start.
+     */
+    initialRuleset: R;
+    /**
+     * A function that should return a Result with an instance of
+     * a Ruleset for the given game.
+     */
+    getRemoteRuleset: GetRemoteRuleset<R, F>;
+};
+/**
+ * Encapsulates ruleset caching and retrieval logic.
+ *
+ * Usually you want to instantiate this class and immediately pass it to
+ * {@link createRulesetResolverBindings} so that you can use it from within
+ * React components with proper re-renders.
+ *
+ * @example
+ * ```ts
+ * import { createRulesetResolverBindings, RulesetResolver } from "@indietabletop/appkit";
+ *
+ * // Instantiate a resolver and export it for any potential use
+ * export const resolver = new RulesetResolver({
+ *   initialRuleset: new Ruleset({ ... }),
+ *   async getRemoteRuleset(version) {
+ *     // Get ruleset from a remote location somehow
+ *     return new Ruleset({ ... });
+ *   },
+ * });
+ *
+ * // Generate resolver-bound hooks for use within React components
+ * export const { useResolveRuleset, useLatestRuleset } =
+ *   createRulesetResolverBindings(resolver);
+ * ```
+ */
+export declare class RulesetResolver<R extends RulesetLike, F> {
+    getRemoteRuleset: GetRemoteRuleset<R, F>;
+    rulesets: Map<string, Success<R> | Failure<F>>;
+    constructor(props: RulesetResolverProps<R, F>);
+    get latest(): R;
+    requests: Map<string, Promise<Success<R> | Failure<F>>>;
+    /**
+     * Resolves a ruleset version if it is currently in memory.
+     *
+     * Otherwise, initiates ruleset resolution from a remote source  in the
+     * background and returns `null`. If you want to know when the freshly
+     * requested ruleset will be resolved, you must use the {@link subscribe}
+     * method (possibly using a hook returned from {@link createRulesetResolverBindings}).
+     */
+    resolve(version: string): Success<R> | Failure<F> | null;
+    /**
+     * Resolves a ruleset from a remote source, deduplicating requests to
+     * identical rulesets.
+     */
+    resolveFromRemote(version: string): Promise<Success<R> | Failure<F>>;
+    listeners: Set<() => void>;
+    subscribe(callback: () => void): void;
+    unsubscribe(callback: () => void): void;
+    notify(): void;
+}
+/**
+ * Given a RulesetResolver, creates bound React hooks that trigger re-renders
+ * when new rulesets are resolved by the resolver.
+ *
+ * Usually you will create these hooks in their own module and export them
+ * for further use.
+ *
+ * @example
+ * ```ts
+ * export const resolver = new RulesetResolver({ ... });
+ *
+ * export const { useResolveRuleset, useLatestRuleset } =
+ *   createRulesetResolverHooks(resolver);
+ * ```
+ */
+export declare function createRulesetResolverBindings<Ruleset extends RulesetLike, Failure>(resolver: RulesetResolver<Ruleset, Failure>): {
+    useLatestRuleset: () => Ruleset;
+    useResolveRuleset: (version: string | null | undefined) => Pending | Success<Ruleset> | import('./async-op.ts').Failure<Failure>;
+};
+export {};

package/dist/SafariCheck/SafariCheck.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+/**
+ * Checks whether the browser which is running the app is Safari/Safari Mobile
+ * and warns the user that their data might be deleted due to inactivity.
+ *
+ * The warning will be shown if:
+ *
+ * - The check has not been explicitly disabled via `performCheck: false`
+ * - The warning has not been previously dismissed (as reported by localStorage)
+ * - The app is not installed (Safari behaves differently in that case)
+ * - The user is not already logged in (as data will be safely backed up that way)
+ */
+export declare function SafariCheck(props: {
+    children: ReactNode;
+    /**
+     * Optionally opt out of the check.
+     *
+     * This can be useful in cases where, e.g. the user already has some content
+     * in the app and we want to avoid checking the user agent, but it is
+     * impractical to entirely avoid rendering this component.
+     */
+    performCheck?: boolean;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/SafariCheck/SafariCheck.stories.d.ts

@@ -0,0 +1,73 @@
+export declare const SafariDesktop: import('@storybook/react').ReactStory<import('@storybook/react').ReactTypes & import('@storybook/addon-docs').DocsTypes & {
+    csf4: true;
+} & {
+    args: {
+        children: import('react').ReactNode;
+        performCheck?: boolean | undefined;
+    };
+}, {
+    args: {
+        children: import("react/jsx-runtime").JSX.Element;
+    };
+    parameters: {
+        msw: {
+            handlers: {
+                ua: import('msw').HttpHandler;
+            };
+        };
+    };
+}>;
+export declare const SafariMobile: import('@storybook/react').ReactStory<import('@storybook/react').ReactTypes & import('@storybook/addon-docs').DocsTypes & {
+    csf4: true;
+} & {
+    args: {
+        children: import('react').ReactNode;
+        performCheck?: boolean | undefined;
+    };
+}, {
+    args: {
+        children: import("react/jsx-runtime").JSX.Element;
+    };
+    parameters: {
+        msw: {
+            handlers: {
+                ua: import('msw').HttpHandler;
+            };
+        };
+    };
+}>;
+export declare const OtherBrowser: import('@storybook/react').ReactStory<import('@storybook/react').ReactTypes & import('@storybook/addon-docs').DocsTypes & {
+    csf4: true;
+} & {
+    args: {
+        children: import('react').ReactNode;
+        performCheck?: boolean | undefined;
+    };
+}, {
+    args: {
+        children: import("react/jsx-runtime").JSX.Element;
+    };
+    parameters: {
+        msw: {
+            handlers: {
+                ua: import('msw').HttpHandler;
+            };
+        };
+    };
+}>;
+/**
+ * The check behaviour has been disabled.
+ */
+export declare const Disabled: import('@storybook/react').ReactStory<import('@storybook/react').ReactTypes & import('@storybook/addon-docs').DocsTypes & {
+    csf4: true;
+} & {
+    args: {
+        children: import('react').ReactNode;
+        performCheck?: boolean | undefined;
+    };
+}, {
+    args: {
+        children: import("react/jsx-runtime").JSX.Element;
+        performCheck: false;
+    };
+}>;

package/dist/SafariCheck/style.css.d.ts

@@ -0,0 +1,17 @@
+export declare const container: string;
+export declare const safariPrompt: string;
+export declare const safariLogo: string;
+export declare const safariPromptHeader: string;
+export declare const safariPromptActions: string;
+export declare const safariDismissArea: string;
+export declare const compatCheckLoaderContainer: string;
+export declare const indicator: string;
+export declare const compatCheckLoaderText: string;
+export declare const emptyStateHeading: string;
+export declare const appIcon: string;
+export declare const dialog: string;
+export declare const heading: string;
+export declare const intro: string;
+export declare const steps: string;
+export declare const step: string;
+export declare const icon: string;

package/dist/ServiceWorkerHandler.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } 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 declare function ServiceWorkerHandler(props: {
+    children: ReactNode;
+    path: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/ShareButton/ShareButton.d.ts

@@ -0,0 +1,57 @@
+import { ButtonProps } from '@ariakit/react';
+import { ReactNode } from 'react';
+type AriakitButtonProps = Omit<ButtonProps, "children" | "onClick" | "value">;
+export type CopyToClipboardButtonProps = AriakitButtonProps & {
+    value: string | null;
+    children: ReactNode;
+    revertAfterMs: number;
+};
+export declare function CopyToClipboardButton(props: CopyToClipboardButtonProps): import("react/jsx-runtime").JSX.Element;
+export type WebShareButtonProps = AriakitButtonProps & {
+    children: ReactNode;
+    shareData: ShareData | null;
+    revertAfterMs: number;
+};
+export declare function WebShareButton(props: WebShareButtonProps): import("react/jsx-runtime").JSX.Element;
+export type ShareButtonProps = AriakitButtonProps & {
+    /**
+     * Button label to use when copy to clipboard is used.
+     */
+    copyLabel: string;
+    /**
+     * Button label to use when web share is used.
+     */
+    shareLabel: string;
+    /**
+     * Data to be shared by the button.
+     *
+     * If using copy to clipboard, only the URL value will be used.
+     */
+    shareData: ShareData | null;
+    /**
+     * How long should the confirmation message be shown within the button?
+     *
+     * @default 1500
+     */
+    revertAfterMs?: number;
+    /**
+     * Should web share be used instead of copy to clipboard?
+     *
+     * By default, web share will be used if the browser supports it.
+     *
+     * @default !!navigator.share
+     */
+    webShare?: boolean;
+};
+/**
+ * An unstyled button that is pre-configured to either copy provided share data
+ * to clipboard, or to use web share, depending on which feature is detected
+ * in the browser where the button is running.
+ *
+ * Props that are not consumed by the Share Button itself are passed to the
+ * underlying Ariakit Button component.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Navigator/share
+ */
+export declare function ShareButton(props: ShareButtonProps): import("react/jsx-runtime").JSX.Element;
+export {};