@gamecrafters/base-ui 0.0.29 → 0.0.30

package/build/components/timer/Timer.types.d.ts

@@ -0,0 +1,64 @@
+import type * as React from "react";
+import type { PolymorphicProps } from "../../utilities/polymorphic";
+import type { ButtonContentProps, ButtonSize, ButtonVariant } from "../button";
+export type TimerUnit = "days" | "hours" | "minutes" | "seconds" | "milliseconds";
+export type TimerStatus = "idle" | "running" | "paused" | "completed";
+export type TimerTime = Record<TimerUnit, number>;
+export type TimerFormattedTime = Record<TimerUnit, string>;
+export type TimerAction = "start" | "pause" | "resume" | "reset";
+export type TimerTickDetails = {
+    value: number;
+    time: TimerTime;
+    formattedTime: TimerFormattedTime;
+};
+type TimerStoreProps = {
+    countdown?: boolean;
+    startMs?: number;
+    targetMs?: number;
+    interval?: number;
+    autoStart?: boolean;
+};
+type TimerCallbacks = {
+    onTick?: (details: TimerTickDetails) => void;
+    onComplete?: () => void;
+};
+export type UseTimerProps = TimerStoreProps & TimerCallbacks;
+export type UseTimerReturn = {
+    value: number;
+    time: TimerTime;
+    formattedTime: TimerFormattedTime;
+    status: TimerStatus;
+    running: boolean;
+    paused: boolean;
+    completed: boolean;
+    start: () => void;
+    pause: () => void;
+    resume: () => void;
+    reset: () => void;
+};
+type TimerOwnProps = TimerStoreProps & {
+    className?: string;
+};
+export type TimerProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", TimerOwnProps> & TimerCallbacks;
+export type TimerElementProps = TimerProps<"div">;
+export type TimerAreaProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    className?: string;
+}>;
+export type TimerItemProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    type: TimerUnit;
+    className?: string;
+}>;
+export type TimerSeparatorProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    className?: string;
+}>;
+export type TimerControlProps<As extends React.ElementType = "div"> = PolymorphicProps<As, "div", {
+    className?: string;
+}>;
+export type TimerActionTriggerProps = Omit<React.ComponentPropsWithoutRef<"button">, "type" | "value"> & ButtonContentProps & {
+    action: TimerAction;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    className?: string;
+};
+export type TimerContextValue = Partial<UseTimerReturn>;
+export {};

package/build/components/timer/TimerActionTrigger.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import type { TimerAction } from "./Timer.types";
+declare const _default: (props: Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "value" | "type"> & import("..").ButtonContentProps & {
+    action: TimerAction;
+    variant?: import("..").ButtonVariant;
+    size?: import("..").ButtonSize;
+    className?: string;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/timer/TimerArea.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "div" : As> & {
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/timer/TimerContext.d.ts

@@ -0,0 +1,2 @@
+export declare const TimerContext: import("react").Context<Partial<import("./Timer.types").UseTimerReturn>>;
+export declare const useTimerContext: () => Partial<import("./Timer.types").UseTimerReturn>;

package/build/components/timer/TimerControl.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "div" : As> & {
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/timer/TimerItem.d.ts

@@ -0,0 +1,8 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "div" : As> & {
+    type: import("./Timer.types").TimerUnit;
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/timer/TimerSeparator.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+declare const _default: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<React.ComponentPropsWithRef<React.ElementType extends As ? "div" : As> & {
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & React.RefAttributes<any>) => React.ReactNode;
+export default _default;

package/build/components/timer/index.d.ts

@@ -0,0 +1,66 @@
+import TimerActionTrigger from "./TimerActionTrigger";
+import TimerArea from "./TimerArea";
+import TimerControl from "./TimerControl";
+import TimerItem from "./TimerItem";
+import TimerSeparator from "./TimerSeparator";
+export declare const Timer: (<As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "div" : As> & {
+    countdown?: boolean;
+    startMs?: number;
+    targetMs?: number;
+    interval?: number;
+    autoStart?: boolean;
+} & {
+    className?: string;
+}, "as"> & {
+    as?: As | undefined;
+} & {
+    onTick?: (details: import("./Timer.types").TimerTickDetails) => void;
+    onComplete?: () => void;
+} & import("react").RefAttributes<any>) => React.ReactNode) & {
+    Root: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "div" : As> & {
+        countdown?: boolean;
+        startMs?: number;
+        targetMs?: number;
+        interval?: number;
+        autoStart?: boolean;
+    } & {
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & {
+        onTick?: (details: import("./Timer.types").TimerTickDetails) => void;
+        onComplete?: () => void;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Area: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "div" : As> & {
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Item: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "div" : As> & {
+        type: import("./Timer.types").TimerUnit;
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Separator: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "div" : As> & {
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    Control: <As extends React.ElementType = "div">(props: import("../../utilities/polymorphic").DistributiveOmit<import("react").ComponentPropsWithRef<import("react").ElementType extends As ? "div" : As> & {
+        className?: string;
+    }, "as"> & {
+        as?: As | undefined;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+    ActionTrigger: (props: Omit<Omit<import("react").DetailedHTMLProps<import("react").ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "value" | "type"> & import("..").ButtonContentProps & {
+        action: import("./Timer.types").TimerAction;
+        variant?: import("..").ButtonVariant;
+        size?: import("..").ButtonSize;
+        className?: string;
+    } & import("react").RefAttributes<any>) => React.ReactNode;
+};
+export { TimerArea, TimerItem, TimerSeparator, TimerControl, TimerActionTrigger };
+export { TimerContext, useTimerContext } from "./TimerContext";
+export { useTimer, DEFAULT_TIMER_INTERVAL } from "./useTimer";
+export { splitTime, formatTime } from "./timerDuration";
+export * from "./Timer.types";

package/build/components/timer/timerDuration.d.ts

@@ -0,0 +1,5 @@
+import dayjs from "dayjs";
+import type { TimerFormattedTime, TimerTime } from "./Timer.types";
+export declare const splitTime: (value: number) => TimerTime;
+export declare const formatTime: (time: TimerTime) => TimerFormattedTime;
+export declare const now: () => dayjs.Dayjs;

package/build/components/timer/useTimer.d.ts

@@ -0,0 +1,3 @@
+import type { UseTimerProps, UseTimerReturn } from "./Timer.types";
+export declare const DEFAULT_TIMER_INTERVAL = 1000;
+export declare const useTimer: (props?: UseTimerProps) => UseTimerReturn;

package/build/hooks/useIsomorphicLayoutEffect.d.ts

@@ -1,2 +1,2 @@
-import { useEffect } from "react";
-export declare const useIsomorphicLayoutEffect: typeof useEffect;
+import { useLayoutEffect } from "react";
+export declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;

package/build/lib/hotkey/hotkey.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Reading a keyboard event as a hotkey string, and putting a written one into the same form so
+ * that the two can be compared.
+ */
+import type { NormalizedSequenceString } from "./sequence";
+declare const normalizedHotkeyBrand: unique symbol;
+/**
+ * A hotkey string with modifier keys in standard order. Build one with `eventToHotkeyString` or
+ * normalize a string via `normalizeHotkey`.
+ *
+ * A full list of key names can be found here:
+ * https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key/Key_Values
+ *
+ * Examples:
+ * "s"                  // Lowercase character for single letters
+ * "S"                  // Uppercase character for shift plus a letter
+ * "1"                  // Number character
+ * "?"                  // Shift plus "/" symbol
+ * "Enter"              // Enter key
+ * "ArrowUp"            // Up arrow
+ * "Control+s"          // Control modifier plus letter
+ * "Control+Alt+Delete" // Multiple modifiers
+ */
+export type NormalizedHotkeyString = NormalizedSequenceString & {
+    [normalizedHotkeyBrand]: true;
+};
+/**
+ * Returns a hotkey character string for keydown and keyup events.
+ *
+ * @example
+ * document.addEventListener("keydown", function (event) {
+ *   if (eventToHotkeyString(event) === "h") ...
+ * })
+ */
+export declare function eventToHotkeyString(event: KeyboardEvent, platform?: string): NormalizedHotkeyString;
+/**
+ * Normalizes a hotkey string before comparing it to the serialized event string produced by
+ * `eventToHotkeyString`.
+ * - Replaces the `Mod` modifier with `Meta` on mac, `Control` on other platforms.
+ * - Ensures modifiers are sorted in a consistent order
+ *
+ * @param hotkey a hotkey string
+ * @param platform NOTE: this param is only intended to be used to mock `navigator.platform` in
+ * tests. `window.navigator.platform` is used by default.
+ * @returns normalized representation of the given hotkey string
+ */
+export declare function normalizeHotkey(hotkey: string, platform?: string | undefined): NormalizedHotkeyString;
+export {};

package/build/lib/hotkey/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Hotkey library
+ *
+ * Fires an element when the key, or the sequence of keys, it was installed under is typed. A field
+ * is focused and anything else is pressed, and every element dispatches a cancellable
+ * `hotkey-fire` event first so a caller can do something else instead.
+ *
+ *     for (const el of document.querySelectorAll("[data-hotkey]")) {
+ *         install(el);
+ *     }
+ *
+ * The hotkey is read from the element's `data-hotkey` attribute, or handed to `install` directly.
+ * A hotkey typed inside a field is meant for the field rather than for the page, unless the field
+ * was named as the hotkey's `data-hotkey-scope`.
+ *
+ * Ported from @github/hotkey (MIT).
+ */
+export { eventToHotkeyString, normalizeHotkey } from "./hotkey";
+export type { NormalizedHotkeyString } from "./hotkey";
+export { SequenceTracker, normalizeSequence, SEQUENCE_DELIMITER } from "./sequence";
+export type { NormalizedSequenceString } from "./sequence";
+export { RadixTrie, Leaf } from "./radix-trie";
+export { isFormField, fireDeterminedAction, expandHotkeyToEdges } from "./utilities";
+/** Registers an element to be fired when its hotkey is typed */
+export declare function install(element: HTMLElement, hotkey?: string): void;
+/** Takes an element back off its hotkey */
+export declare function uninstall(element: HTMLElement): void;

package/build/lib/hotkey/macos-symbol-layer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Map of special symbols to the keys that would be pressed (while holding `Option`) to type them
+ * on macOS on an English layout. Most of these are standardised across most language layouts, so
+ * this will not work 100% in every language but it should work most of the time.
+ */
+export declare const macosSymbolLayerKeys: Record<string, string>;

package/build/lib/hotkey/macos-uppercase-layer.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Map of "uppercase" symbols to the keys that would be pressed (while holding `Shift`) to type
+ * them on macOS on an English layout. Most of these are standardised across most language layouts,
+ * so this will not work 100% in every language but it should work most of the time.
+ */
+export declare const macosUppercaseLayerKeys: Record<string, string>;

package/build/lib/hotkey/radix-trie.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The tree the installed hotkeys are held in. A sequence is stored a key to a level, so that what
+ * has been typed so far is a position in the tree rather than a search through everything
+ * installed: `g c` and `g i` share the `g` above them, and reaching a leaf is what fires.
+ */
+export declare class Leaf<T> {
+    parent: RadixTrie<T>;
+    children: T[];
+    constructor(trie: RadixTrie<T>);
+    delete(value: T): boolean;
+    add(value: T): Leaf<T>;
+}
+export declare class RadixTrie<T> {
+    parent: RadixTrie<T> | null;
+    children: {
+        [key: string]: RadixTrie<T> | Leaf<T>;
+    };
+    constructor(trie?: RadixTrie<T>);
+    get(edge: string): RadixTrie<T> | Leaf<T>;
+    insert(edges: string[]): RadixTrie<T> | Leaf<T>;
+    delete(node: RadixTrie<T> | Leaf<T>): boolean;
+}

package/build/lib/hotkey/sequence.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Keys pressed one after another rather than together, and the wait that holds them as one
+ * sequence before it is given up on.
+ */
+import type { NormalizedHotkeyString } from "./hotkey";
+interface SequenceTrackerOptions {
+    onReset?: () => void;
+}
+/** What stands between one hotkey of a sequence and the next */
+export declare const SEQUENCE_DELIMITER = " ";
+declare const sequenceBrand: unique symbol;
+/**
+ * Sequence of hotkeys, separated by spaces. For example, `Mod+m g`. Obtain one through the
+ * `SequenceTracker` class or by normalizing a string with `normalizeSequence`.
+ */
+export type NormalizedSequenceString = string & {
+    [sequenceBrand]: true;
+};
+export declare class SequenceTracker {
+    /**
+     * How long a part-typed sequence is held before it is given up on. Long enough to reach the
+     * next key without hurrying, short enough that a key pressed later is not read as part of
+     * something typed a moment ago
+     */
+    static readonly CHORD_TIMEOUT = 1500;
+    private _path;
+    private timer;
+    private onReset;
+    constructor({ onReset }?: SequenceTrackerOptions);
+    get path(): readonly NormalizedHotkeyString[];
+    get sequence(): NormalizedSequenceString;
+    registerKeypress(event: KeyboardEvent): void;
+    reset(): void;
+    private killTimer;
+    private startTimer;
+}
+/** Puts every hotkey of a sequence into the one form, so that two sequences can be compared */
+export declare function normalizeSequence(sequence: string): NormalizedSequenceString;
+export {};

package/build/lib/hotkey/utilities.d.ts

@@ -0,0 +1,21 @@
+/**
+ * What a hotkey does when it fires, and how a written hotkey is read into the edges of the tree
+ * the installed ones are held in.
+ */
+import type { NormalizedHotkeyString } from "./hotkey";
+/**
+ * Whether the element is one a reader types into. A hotkey pressed inside one of these is meant
+ * for the field rather than for the page, unless the field was named as a scope.
+ */
+export declare function isFormField(element: Node): boolean;
+/**
+ * Fires the element a hotkey was installed on: a field is focused and anything else is pressed.
+ * The `hotkey-fire` event is dispatched first and can be cancelled, so a caller who wants
+ * something else to happen says so there.
+ */
+export declare function fireDeterminedAction(el: HTMLElement, path: readonly NormalizedHotkeyString[]): void;
+/**
+ * Reads a hotkey string into the sequences it stands for, each of those being the edges walked
+ * down the tree to reach it. `a b,Control+/` is two: `["a", "b"]` and `["Control+/"]`.
+ */
+export declare function expandHotkeyToEdges(hotkey: string): NormalizedHotkeyString[][];