@blastlauncher/runtime 1.0.1 → 3.0.0-alpha.0

package/dist/api/form.js

@@ -0,0 +1,345 @@
+import { Children, createContext, createElement, forwardRef, isValidElement, useContext, useEffect, useImperativeHandle, useLayoutEffect, useMemo, useRef, useState, } from "react";
+import { requestCapability } from "./capability.js";
+import { DatePickerType } from "./enums.generated.js";
+import { environment } from "./environment.js";
+import { RootNavigationEntryContext } from "./navigation.js";
+import { slot } from "./slot.js";
+/** `Form.DatePicker.Type`: what a date picker lets the user pick. */
+export { DatePickerType };
+let launchDraft;
+/** Installed before importing the command, alongside its launch props. */
+export function setFormDraftValues(values) {
+    launchDraft = values;
+}
+const FormContext = createContext(null);
+// A Date does not round-trip through JSON; everything else in `FormValue`
+// does, so only Dates need a tagged encoding.
+function encodeValue(value) {
+    return value instanceof Date ? { $date: value.toISOString() } : value;
+}
+function decodeValue(value) {
+    if (value && typeof value === "object" && !Array.isArray(value) && "$date" in value) {
+        const date = new Date(value.$date);
+        if (Number.isFinite(date.getTime()))
+            return date;
+        throw new Error("Invalid stored Form date");
+    }
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value)) ||
+        (Array.isArray(value) &&
+            (value.every((v) => typeof v === "string") ||
+                value.every((v) => typeof v === "number" && Number.isFinite(v)))))
+        return value;
+    throw new Error("Invalid stored Form value");
+}
+/** Decodes a stored or wire-carried values object back into typed `FormValue`s. */
+export function decodeFormValues(values) {
+    const result = {};
+    for (const [id, value] of Object.entries(values)) {
+        try {
+            Object.defineProperty(result, id, { value: decodeValue(value), enumerable: true });
+        }
+        catch {
+            /* Ignore stale or malformed draft entries. */
+        }
+    }
+    return result;
+}
+function fieldKey(id) {
+    return `blast:field:${JSON.stringify([environment.commandName, id])}`;
+}
+function draftKey() {
+    return `blast:draft:${environment.commandName}`;
+}
+const pendingWrites = new Set();
+function writeStorage(name, params) {
+    const promise = requestCapability(name, params);
+    pendingWrites.add(promise);
+    void promise.then(() => pendingWrites.delete(promise), () => pendingWrites.delete(promise));
+    return promise;
+}
+/** Graceful shutdown must receive the host's write acknowledgements before exiting. */
+export async function flushFormPersistence() {
+    await Promise.allSettled(pendingWrites);
+}
+async function saveDraft(fields, id, next) {
+    const values = {};
+    for (const [fieldId, entry] of fields) {
+        if (!entry.secret)
+            values[fieldId] = encodeValue(entry.read());
+    }
+    values[id] = encodeValue(next);
+    await writeStorage("storage.set", {
+        scope: "blast:internal",
+        key: draftKey(),
+        value: JSON.stringify(values),
+    });
+}
+async function clearDraft() {
+    await writeStorage("storage.remove", { scope: "blast:internal", key: draftKey() });
+}
+function Field({ kind, initial, secret, fieldRef, ...props }) {
+    const ctx = useContext(FormContext);
+    const draft = !secret ? ctx?.draft?.[props.id] : undefined;
+    const [local, setLocal] = useState((draft !== undefined ? draft : (props.defaultValue ?? initial)));
+    const value = props.value !== undefined ? props.value : local;
+    const current = useRef(value);
+    current.current = value;
+    const edited = useRef(false);
+    const key = fieldKey(props.id);
+    // Restoring a stored value behaves like an uncontrolled `defaultValue`
+    // update that arrives after mount; a concurrent edit always wins.
+    useEffect(() => {
+        if (secret || draft !== undefined || !props.storeValue || props.value !== undefined)
+            return;
+        let mounted = true;
+        void requestCapability("storage.get", { scope: "blast:internal", key })
+            .then((stored) => {
+            if (!mounted || edited.current || typeof stored !== "string")
+                return;
+            const restored = decodeValue(JSON.parse(stored));
+            if (kind === "DatePicker"
+                ? restored !== null && !(restored instanceof Date)
+                : Array.isArray(initial)
+                    ? !Array.isArray(restored) || !restored.every((v) => typeof v === "string")
+                    : typeof restored !== typeof initial)
+                return;
+            current.current = restored;
+            setLocal(restored);
+            props.onChange?.(restored);
+        })
+            .catch((error) => console.error("Form field restore failed", error));
+        return () => {
+            mounted = false;
+        };
+    }, [key, secret, draft, props.storeValue, props.value]);
+    const callbacks = useRef(props);
+    callbacks.current = props;
+    useLayoutEffect(() => {
+        if (!ctx)
+            return;
+        const read = () => current.current;
+        ctx.fields.set(props.id, {
+            read,
+            secret: !!secret,
+            event: (type) => {
+                const callback = type === "focus" ? callbacks.current.onFocus : callbacks.current.onBlur;
+                callback?.({ target: { id: props.id, value: current.current }, type });
+            },
+        });
+        return () => {
+            if (ctx.fields.get(props.id)?.read === read)
+                ctx.fields.delete(props.id);
+        };
+    }, [ctx?.fields, props.id, secret]);
+    useEffect(() => {
+        if (props.autoFocus)
+            ctx?.focus(props.id);
+    }, [ctx?.focus, props.id, props.autoFocus]);
+    function change(next) {
+        edited.current = true;
+        if (props.value === undefined) {
+            current.current = next;
+            setLocal(next);
+        }
+        props.onChange?.(next);
+        if (secret)
+            return;
+        if (props.storeValue) {
+            void writeStorage("storage.set", {
+                scope: "blast:internal",
+                key,
+                value: JSON.stringify(encodeValue(next)),
+            }).catch((error) => console.error("Form field save failed", error));
+        }
+        if (ctx?.enableDrafts) {
+            void saveDraft(ctx.fields, props.id, next).catch((error) => console.error("Form draft save failed", error));
+        }
+    }
+    useImperativeHandle(fieldRef, () => ({
+        focus: () => ctx?.focus(props.id),
+        reset: () => change((props.defaultValue ?? initial)),
+    }), [ctx, props, initial]);
+    const scene = { ...props };
+    // Secret fields (PasswordField) keep their value runtime-side only: the scene
+    // carries a boolean `hasValue` instead of `value`/`defaultValue`, so published
+    // scenes and client logs never contain the secret.
+    if (secret) {
+        delete scene.value;
+        delete scene.defaultValue;
+        scene.hasValue = value !== undefined && value !== null && value !== "";
+    }
+    else {
+        scene.value = value;
+    }
+    scene.focused = ctx?.focusedId === props.id;
+    return createElement(`Form.${kind}`, {
+        ...scene,
+        onChange: (input) => {
+            // Dates arrive from clients as ISO strings; extension callbacks see Dates.
+            const next = (kind === "DatePicker" && typeof input === "string" ? new Date(input) : input);
+            change(next);
+        },
+        onFocus: () => ctx?.focus(props.id),
+        onBlur: () => {
+            ctx?.blur(props.id);
+        },
+    });
+}
+function TextField(props, ref) {
+    return createElement(Field, { ...props, kind: "TextField", initial: "", fieldRef: ref });
+}
+function PasswordField(props, ref) {
+    return createElement(Field, {
+        ...props,
+        kind: "PasswordField",
+        initial: "",
+        secret: true,
+        fieldRef: ref,
+    });
+}
+function TextArea(props, ref) {
+    return createElement(Field, { ...props, kind: "TextArea", initial: "", fieldRef: ref });
+}
+function Checkbox(props, ref) {
+    return createElement(Field, {
+        ...props,
+        kind: "Checkbox",
+        initial: false,
+        fieldRef: ref,
+    });
+}
+const DatePicker = Object.assign(forwardRef(function DatePicker(props, ref) {
+    return createElement(Field, {
+        ...props,
+        kind: "DatePicker",
+        initial: null,
+        fieldRef: ref,
+    });
+}), {
+    Type: DatePickerType,
+    /** Whether the date is a full day: non-null with local time exactly midnight. */
+    isFullDay(date) {
+        return (!!date &&
+            date.getHours() === 0 &&
+            date.getMinutes() === 0 &&
+            date.getSeconds() === 0 &&
+            date.getMilliseconds() === 0);
+    },
+});
+function FilePicker(props, ref) {
+    return createElement(Field, {
+        allowMultipleSelection: true,
+        canChooseDirectories: false,
+        canChooseFiles: true,
+        showHiddenFiles: false,
+        ...props,
+        kind: "FilePicker",
+        initial: [],
+        fieldRef: ref,
+    });
+}
+const TagPicker = Object.assign(forwardRef(function TagPicker(props, ref) {
+    return createElement(Field, {
+        ...props,
+        kind: "TagPicker",
+        initial: [],
+        fieldRef: ref,
+    });
+}), {
+    Item: (props) => createElement("Form.TagPicker.Item", props),
+});
+function firstValue(children) {
+    for (const child of Children.toArray(children)) {
+        if (!isValidElement(child))
+            continue;
+        const value = child.props.value ?? firstValue(child.props.children);
+        if (value !== undefined)
+            return value;
+    }
+}
+const Dropdown = Object.assign(forwardRef(function Dropdown(props, ref) {
+    return createElement(Field, {
+        ...props,
+        kind: "Dropdown",
+        initial: firstValue(props.children) ?? "",
+        fieldRef: ref,
+    });
+}), {
+    Item: (props) => createElement("Form.Dropdown.Item", props),
+    Section: (props) => createElement("Form.Dropdown.Section", props),
+});
+export const Form = Object.assign(function Form({ children, actions, searchBarAccessory, ...props }) {
+    const [fields] = useState(() => new Map());
+    const [focusedId, setFocusedId] = useState(null);
+    const parent = useContext(FormContext);
+    const rootEntry = useContext(RootNavigationEntryContext);
+    const enableDrafts = rootEntry && !parent && !!props.enableDrafts;
+    const [draft] = useState(() => (enableDrafts ? launchDraft : undefined));
+    const manager = useMemo(() => {
+        let active = null;
+        const focus = (id) => {
+            if (id === active)
+                return;
+            if (active !== null)
+                fields.get(active)?.event("blur");
+            active = id;
+            setFocusedId(id);
+            if (id !== null)
+                fields.get(id)?.event("focus");
+        };
+        return {
+            focus,
+            blur: (id) => {
+                if (active === id)
+                    focus(null);
+            },
+        };
+    }, [fields]);
+    const ctx = useMemo(() => ({
+        fields,
+        enableDrafts,
+        focusedId,
+        ...manager,
+        draft,
+    }), [fields, enableDrafts, focusedId, manager, draft]);
+    return createElement(FormContext.Provider, { value: ctx }, createElement("Form", props, children, slot("actions", actions), slot("searchBarAccessory", searchBarAccessory)));
+}, {
+    FilePicker: forwardRef(FilePicker),
+    TagPicker,
+    PasswordField: forwardRef(PasswordField),
+    TextField: forwardRef(TextField),
+    TextArea: forwardRef(TextArea),
+    Checkbox: forwardRef(Checkbox),
+    DatePicker,
+    Dropdown,
+    LinkAccessory: (props) => createElement("Form.LinkAccessory", props),
+    Description: (props) => createElement("Form.Description", props),
+    Separator: (props) => createElement("Form.Separator", props),
+});
+export function SubmitForm({ onSubmit, title, ...props }) {
+    const ctx = useContext(FormContext);
+    const [submissionFailureCount, setSubmissionFailureCount] = useState(0);
+    return createElement("Action.SubmitForm", {
+        submissionFailureCount,
+        ...props,
+        title: title ?? "Submit Form",
+        onAction: () => {
+            const values = Object.fromEntries(Array.from(ctx?.fields ?? [], ([id, entry]) => [id, entry.read()]));
+            const result = onSubmit?.(values);
+            const complete = (success) => {
+                if (success === false)
+                    setSubmissionFailureCount((count) => count + 1);
+                if (ctx?.enableDrafts && success !== false) {
+                    void clearDraft().catch((error) => console.error("Form draft clear failed", error));
+                }
+                return success;
+            };
+            return result instanceof Promise ? result.then(complete) : complete(result);
+        },
+    });
+}
+// `Action.SubmitForm` and its deprecated alias declare a `displayName`.
+SubmitForm.displayName = "SubmitForm";

package/dist/api/grid.d.ts

@@ -0,0 +1,293 @@
+import { type ReactNode } from "react";
+import { GridFit, GridInset, GridItemSize } from "./enums.generated.js";
+import type { ColorLike, ImageLike } from "./types.js";
+/** `Grid.ItemSize`: the size of the grid's items; deprecated for `columns`. */
+export type GridItemSize = (typeof GridItemSize)[keyof typeof GridItemSize];
+/** `Grid.Inset`: space between an item's content and its borders. */
+export type GridInset = (typeof GridInset)[keyof typeof GridInset];
+/** `Grid.Fit`: how item content fits its cell. */
+export type GridFit = (typeof GridFit)[keyof typeof GridFit];
+/** Allowed `aspectRatio` values, widened from the `GridAspectRatio` enum. */
+export type GridAspectRatio = "1" | "3/2" | "2/3" | "4/3" | "3/4" | "16/9" | "9/16";
+/** `Grid.Item.Props.content`: an image, a color, or either with a tooltip. */
+export type GridItemContent = ImageLike | {
+    color: ColorLike;
+} | {
+    value: ImageLike | {
+        color: ColorLike;
+    };
+    tooltip: string;
+};
+/** `Grid.Item.Accessory`: an optional icon with a tooltip, under the item. */
+export interface GridItemAccessory {
+    /** An optional image shown underneath the item. */
+    icon?: ImageLike | null;
+    /** An optional tooltip shown when the accessory is hovered. */
+    tooltip?: string | null;
+}
+export interface GridProps {
+    /** Grid sections or items. */
+    children?: ReactNode;
+    /** The main title for that view displayed in the host. */
+    navigationTitle?: string;
+    /** Indicates whether a loading bar should be shown below the search bar. */
+    isLoading?: boolean;
+    /** The text that will be displayed in the search bar. */
+    searchText?: string;
+    /** Placeholder text of the search bar. */
+    searchBarPlaceholder?: string;
+    /**
+     * Toggles client-side filtering of the items through the search bar; the
+     * client decides how to honor it (see task 0020, "Out of scope").
+     */
+    filtering?: boolean | {
+        keepSectionOrder: boolean;
+    };
+    /** Deprecated; use `filtering` instead. */
+    enableFiltering?: boolean;
+    /**
+     * Defines whether the `onSearchTextChange` handler fires on every keystroke
+     * or with a throttling delay.
+     */
+    throttle?: boolean;
+    /** Callback triggered when the search bar text changes. */
+    onSearchTextChange?: (text: string) => void;
+    /** Callback triggered when the item selection in the grid changes. */
+    onSelectionChange?: (id: string | null) => void;
+    /** Selects the item with the specified id. */
+    selectedItemId?: string;
+    /** Column count for the grid's sections. */
+    columns?: number;
+    /** Deprecated; use `columns` instead. */
+    itemSize?: GridItemSize;
+    /** Aspect ratio for the `Grid.Item` elements. */
+    aspectRatio?: GridAspectRatio;
+    /** Fit for the `Grid.Item` element content. */
+    fit?: GridFit;
+    /** Space between a `Grid.Item`'s content and its borders. */
+    inset?: GridInset;
+    /**
+     * Pagination configuration; `onLoadMore` fires when the client loads the
+     * next page (Blast records the request like any other handler).
+     */
+    pagination?: {
+        pageSize: number;
+        hasMore: boolean;
+        onLoadMore: () => void;
+    };
+    /** An ActionPanel; rendered as a `Slot` child named `actions`. */
+    actions?: ReactNode;
+    /** A search bar accessory; rendered as a `Slot` child named `searchBarAccessory`. */
+    searchBarAccessory?: ReactNode;
+}
+export interface GridItemProps {
+    /** Passed to the `onSelectionChange` handler of the Grid when selected. */
+    id?: string;
+    /** An image or color, optionally with a tooltip, representing the content. */
+    content: GridItemContent;
+    /** An optional title displayed below the content. */
+    title?: string;
+    /** An optional subtitle displayed below the title. */
+    subtitle?: string;
+    /** Additional indexable strings for search. */
+    keywords?: string[];
+    /** An optional accessory displayed underneath the item. */
+    accessory?: GridItemAccessory;
+    /** Optional information to preview files with Quick Look. */
+    quickLook?: {
+        name?: string | null;
+        path: string;
+    };
+    /** An ActionPanel; rendered as a `Slot` child named `actions`. */
+    actions?: ReactNode;
+}
+export interface GridSectionProps {
+    /** The `Grid.Item` elements of the section. */
+    children?: ReactNode;
+    /** Title displayed above the section. */
+    title?: string;
+    /** An optional subtitle displayed next to the title of the section. */
+    subtitle?: string;
+    /** Column count for the section. */
+    columns?: number;
+    /** Aspect ratio for the section's `Grid.Item` elements. */
+    aspectRatio?: GridAspectRatio;
+    /** Fit for the section's `Grid.Item` element content. */
+    fit?: GridFit;
+    /** Space between the section's `Grid.Item` content and its borders. */
+    inset?: GridInset;
+}
+export interface GridEmptyViewProps {
+    /** The main title displayed for the empty view. */
+    title?: string;
+    /** An optional description for why the empty view is shown. */
+    description?: string;
+    /** An optional icon displayed in the center of the empty view. */
+    icon?: ImageLike | null;
+    /** An ActionPanel; rendered as a `Slot` child named `actions`. */
+    actions?: ReactNode;
+}
+export interface GridDropdownItemProps {
+    /** Value of the dropdown item; passed to `onChange` when selected. */
+    value: string;
+    /** The title displayed for the item. */
+    title: string;
+    /** An optional icon displayed for the item. */
+    icon?: ImageLike | null;
+    /** Additional indexable strings for search. */
+    keywords?: string[];
+}
+export interface GridDropdownSectionProps {
+    /** The `Grid.Dropdown.Item` elements of the section. */
+    children?: ReactNode;
+    /** Title displayed above the section. */
+    title?: string;
+}
+export interface GridDropdownProps {
+    /** The dropdown sections or items. */
+    children?: ReactNode;
+    /** ID of the dropdown. */
+    id?: string;
+    /** Tooltip displayed when hovering the dropdown. */
+    tooltip: string;
+    /** Placeholder text shown in the dropdown search field. */
+    placeholder?: string;
+    /**
+     * Persist the selected value per command and dropdown id across runs.
+     */
+    storeValue?: boolean;
+    /** The current value of the dropdown. */
+    value?: string;
+    /** The default value of the dropdown, configured once per component lifecycle. */
+    defaultValue?: string;
+    /** Toggles client-side filtering of the dropdown items. */
+    filtering?: boolean | {
+        keepSectionOrder: boolean;
+    };
+    /** Indicates whether a loading indicator should be shown next to the dropdown. */
+    isLoading?: boolean;
+    /** Defines whether `onSearchTextChange` fires on every keystroke or throttled. */
+    throttle?: boolean;
+    /** Callback triggered when the dropdown search field text changes. */
+    onSearchTextChange?: (text: string) => void;
+    /** Callback triggered when the dropdown selection changes. */
+    onChange?: (newValue: string) => void;
+}
+declare const GridDropdownItem: (props: GridDropdownItemProps) => import("react").ReactElement<GridDropdownItemProps, string | import("react").JSXElementConstructor<any>>;
+declare const GridDropdownSection: (props: GridDropdownSectionProps) => import("react").DOMElement<GridDropdownSectionProps, Element>;
+declare const GridItem: (props: GridItemProps) => import("react").ReactElement<{
+    /** Passed to the `onSelectionChange` handler of the Grid when selected. */
+    id?: string;
+    /** An image or color, optionally with a tooltip, representing the content. */
+    content: GridItemContent;
+    /** An optional title displayed below the content. */
+    title?: string;
+    /** An optional subtitle displayed below the title. */
+    subtitle?: string;
+    /** Additional indexable strings for search. */
+    keywords?: string[];
+    /** An optional accessory displayed underneath the item. */
+    accessory?: GridItemAccessory;
+    /** Optional information to preview files with Quick Look. */
+    quickLook?: {
+        name?: string | null;
+        path: string;
+    };
+}, string | import("react").JSXElementConstructor<any>>;
+declare function GridSection(props: GridSectionProps): import("react").DOMElement<GridSectionProps, Element>;
+declare function GridEmptyView(props: GridEmptyViewProps): import("react").ReactElement<{
+    /** The main title displayed for the empty view. */
+    title?: string;
+    /** An optional description for why the empty view is shown. */
+    description?: string;
+    /** An optional icon displayed in the center of the empty view. */
+    icon?: ImageLike | null;
+}, string | import("react").JSXElementConstructor<any>>;
+export declare const Grid: ((props: GridProps) => import("react").ReactElement<{
+    /** The main title for that view displayed in the host. */
+    navigationTitle?: string;
+    /** Indicates whether a loading bar should be shown below the search bar. */
+    isLoading?: boolean;
+    /** The text that will be displayed in the search bar. */
+    searchText?: string;
+    /** Placeholder text of the search bar. */
+    searchBarPlaceholder?: string;
+    /**
+     * Toggles client-side filtering of the items through the search bar; the
+     * client decides how to honor it (see task 0020, "Out of scope").
+     */
+    filtering?: boolean | {
+        keepSectionOrder: boolean;
+    };
+    /** Deprecated; use `filtering` instead. */
+    enableFiltering?: boolean;
+    /**
+     * Defines whether the `onSearchTextChange` handler fires on every keystroke
+     * or with a throttling delay.
+     */
+    throttle?: boolean;
+    /** Callback triggered when the search bar text changes. */
+    onSearchTextChange?: (text: string) => void;
+    /** Callback triggered when the item selection in the grid changes. */
+    onSelectionChange?: (id: string | null) => void;
+    /** Selects the item with the specified id. */
+    selectedItemId?: string;
+    /** Column count for the grid's sections. */
+    columns?: number;
+    /** Deprecated; use `columns` instead. */
+    itemSize?: GridItemSize;
+    /** Aspect ratio for the `Grid.Item` elements. */
+    aspectRatio?: GridAspectRatio;
+    /** Fit for the `Grid.Item` element content. */
+    fit?: GridFit;
+    /** Space between a `Grid.Item`'s content and its borders. */
+    inset?: GridInset;
+    /**
+     * Pagination configuration; `onLoadMore` fires when the client loads the
+     * next page (Blast records the request like any other handler).
+     */
+    pagination?: {
+        pageSize: number;
+        hasMore: boolean;
+        onLoadMore: () => void;
+    };
+}, string | import("react").JSXElementConstructor<any>>) & {
+    Item: typeof GridItem;
+    Section: typeof GridSection;
+    EmptyView: typeof GridEmptyView;
+    Dropdown: ((props: GridDropdownProps) => import("react").ReactElement<{
+        children?: ReactNode;
+        id?: string;
+        tooltip: string;
+        placeholder?: string;
+        storeValue?: boolean;
+        defaultValue?: string;
+        filtering?: boolean | {
+            keepSectionOrder: boolean;
+        };
+        isLoading?: boolean;
+        throttle?: boolean;
+        onSearchTextChange?: (text: string) => void;
+        value: string | undefined;
+        onChange: ((value: string) => void | undefined) | undefined;
+    }, string | import("react").JSXElementConstructor<any>>) & {
+        Item: typeof GridDropdownItem;
+        Section: typeof GridDropdownSection;
+    };
+    Inset: {
+        readonly Zero: "zero";
+        readonly Small: "sm";
+        readonly Medium: "md";
+        readonly Large: "lg";
+    };
+    ItemSize: {
+        readonly Small: "small";
+        readonly Medium: "medium";
+        readonly Large: "large";
+    };
+    Fit: {
+        readonly Contain: "contain";
+        readonly Fill: "fill";
+    };
+};
+export {};

package/dist/api/grid.js

@@ -0,0 +1,36 @@
+import { createElement } from "react";
+import { useDropdown } from "./dropdown.js";
+import { GridFit, GridInset, GridItemSize } from "./enums.generated.js";
+import { slot } from "./slot.js";
+const GridDropdownItem = function GridDropdownItem(props) {
+    return createElement("Grid.Dropdown.Item", props);
+};
+const GridDropdownSection = function GridDropdownSection(props) {
+    return createElement("Grid.Dropdown.Section", props);
+};
+const GridDropdown = Object.assign(function GridDropdown(props) {
+    return useDropdown("Grid.Dropdown", props);
+}, { Item: GridDropdownItem, Section: GridDropdownSection });
+const GridItem = function GridItem(props) {
+    const { actions, ...rest } = props;
+    return createElement("Grid.Item", rest, slot("actions", actions));
+};
+function GridSection(props) {
+    return createElement("Grid.Section", props);
+}
+function GridEmptyView(props) {
+    const { actions, ...rest } = props;
+    return createElement("Grid.EmptyView", rest, slot("actions", actions));
+}
+export const Grid = Object.assign(function Grid(props) {
+    const { actions, searchBarAccessory, children, ...rest } = props;
+    return createElement("Grid", rest, children, slot("actions", actions), slot("searchBarAccessory", searchBarAccessory));
+}, {
+    Item: GridItem,
+    Section: GridSection,
+    EmptyView: GridEmptyView,
+    Dropdown: GridDropdown,
+    Inset: GridInset,
+    ItemSize: GridItemSize,
+    Fit: GridFit,
+});