@blastlauncher/runtime 1.0.5 → 3.0.0-alpha.0

package/dist/api/action.js

@@ -0,0 +1,260 @@
+import { createElement } from "react";
+import { copy, paste } from "./clipboard.js";
+import { requestCapability } from "./capability.js";
+import { useNavigation } from "./navigation.js";
+import { SubmitForm } from "./form.js";
+import { ActionStyle, DatePickerType_2, Icon } from "./enums.generated.js";
+import { applicationParam, open } from "./open.js";
+// `isFullDay` from the declarations: a date without a local time component is
+// a full day.
+function isFullDay(date) {
+    if (!date || Number.isNaN(date.getTime()))
+        return false;
+    return (date.getHours() === 0 &&
+        date.getMinutes() === 0 &&
+        date.getSeconds() === 0 &&
+        date.getMilliseconds() === 0);
+}
+export const PickDate = Object.assign(function PickDate(props) {
+    const { onChange, min, max, ...rest } = props;
+    return createElement("Action.PickDate", {
+        ...rest,
+        icon: rest.icon ?? Icon.Calendar,
+        // Dates arrive from clients as ISO strings; extension callbacks see
+        // Dates (the same wire rule as Form.DatePicker).
+        onChange: (value) => onChange(typeof value === "string" ? new Date(value) : null),
+        // `Date` objects cannot cross the wire: the bounds travel as ISO strings.
+        ...(min === undefined ? {} : { min: min.toISOString() }),
+        ...(max === undefined ? {} : { max: max.toISOString() }),
+    });
+}, 
+// `Action.PickDate.Type` and `.isFullDay` are members, exactly as declared.
+{ Type: DatePickerType_2, isFullDay });
+export const Action = Object.assign(function Action(props) {
+    return createElement("Action", props);
+}, {
+    CopyToClipboard,
+    CreateQuicklink,
+    CreateSnippet,
+    InstallMCPServer,
+    Open,
+    OpenInBrowser,
+    OpenWith,
+    Paste,
+    PickDate,
+    Push,
+    ShowInFinder,
+    SubmitForm,
+    ToggleQuickLook,
+    Trash,
+    Style: ActionStyle,
+});
+export function CopyToClipboard(props) {
+    const { content, onCopy, title, transient, ...rest } = props;
+    // `content` stays in the runtime: clipboard payloads (possibly concealed
+    // secrets) must not be broadcast to clients in the scene. `transient` is the
+    // deprecated `concealed` flag and travels with the copy request instead.
+    return createElement("Action.CopyToClipboard", {
+        ...rest,
+        title: title ?? "Copy to Clipboard",
+        onAction: () => copy(content, transient === undefined ? undefined : { transient }).then(() => onCopy?.(content)),
+    });
+}
+export function OpenInBrowser(props) {
+    const { url, onOpen, title, icon, ...rest } = props;
+    return createElement("Action.OpenInBrowser", {
+        ...rest,
+        title: title ?? "Open in Browser",
+        icon: icon ?? Icon.Globe,
+        onAction: async () => {
+            await requestCapability("open.url", { url });
+            onOpen?.(url);
+        },
+    });
+}
+export function Paste(props) {
+    const { content, onPaste, title, icon, ...rest } = props;
+    return createElement("Action.Paste", {
+        ...rest,
+        title: title ?? "Paste in Active App",
+        icon: icon ?? Icon.Clipboard,
+        onAction: async () => {
+            await paste(content);
+            onPaste?.(content);
+        },
+    });
+}
+export { CopyToClipboard as CopyToClipboardAction, Paste as PasteAction };
+export function Push({ target, onPush, onPop, ...props }) {
+    const { push } = useNavigation();
+    return createElement("Action.Push", {
+        ...props,
+        onAction: () => {
+            push(target, onPop);
+            onPush?.();
+        },
+    });
+}
+export { Push as PushAction };
+/** Normalizes a `PathLike` for the wire; mirrors the check in `applications.ts`. */
+function pathParam(path, api) {
+    if (typeof path !== "string" && !(path instanceof URL) && !Buffer.isBuffer(path)) {
+        throw new TypeError(`${api}: path must be a string, Buffer or URL`);
+    }
+    const value = String(path);
+    if (value === "")
+        throw new TypeError(`${api}: path must not be empty`);
+    return value;
+}
+export function Open(props) {
+    const { target, application, onOpen, ...rest } = props;
+    // `target` may be a private path: it reaches the host only through the
+    // capability request, never the scene.
+    return createElement("Action.Open", {
+        ...rest,
+        icon: rest.icon ?? Icon.Finder,
+        onAction: async () => {
+            await open(target, application);
+            onOpen?.(target);
+        },
+    });
+}
+/** Deprecated alias of `Action.Open`. */
+export const OpenAction = Open;
+export function OpenWith(props) {
+    const { path, onOpen, ...rest } = props;
+    // `path` stays private, like every `Action.Open*` payload. The client picks
+    // the application, so no application param is sent here.
+    return createElement("Action.OpenWith", {
+        ...rest,
+        title: rest.title ?? "Open With",
+        icon: rest.icon ?? Icon.Upload,
+        onAction: async () => {
+            await open(path);
+            onOpen?.(path);
+        },
+    });
+}
+/** Deprecated alias of `Action.OpenWith`. */
+export const OpenWithAction = OpenWith;
+export function ShowInFinder(props) {
+    const { path, onShow, ...rest } = props;
+    return createElement("Action.ShowInFinder", {
+        ...rest,
+        title: rest.title ?? "Show in Finder",
+        icon: rest.icon ?? Icon.Finder,
+        onAction: async () => {
+            await requestCapability("finder.show", { path: pathParam(path, "Action.ShowInFinder") });
+            // The callback sees the value as passed, like the declarations promise.
+            onShow?.(path);
+        },
+    });
+}
+/** Deprecated alias of `Action.ShowInFinder`. */
+export const ShowInFinderAction = ShowInFinder;
+export function Trash(props) {
+    const { paths, onTrash, ...rest } = props;
+    const items = Array.isArray(paths) ? paths : [paths];
+    return createElement("Action.Trash", {
+        ...rest,
+        title: rest.title ?? "Move to Trash",
+        icon: rest.icon ?? Icon.Trash,
+        onAction: async () => {
+            await requestCapability("trash", {
+                paths: items.map((item) => pathParam(item, "Action.Trash")),
+            });
+            onTrash?.(paths);
+        },
+    });
+}
+/** Deprecated alias of `Action.Trash`. */
+export const TrashAction = Trash;
+export function CreateSnippet(props) {
+    const { snippet, ...rest } = props;
+    // The snippet contents are private: out of the scene, into the capability.
+    const params = {
+        text: snippet.text,
+        ...(snippet.name === undefined ? {} : { name: snippet.name }),
+        ...(snippet.keyword === undefined ? {} : { keyword: snippet.keyword }),
+    };
+    return createElement("Action.CreateSnippet", {
+        ...rest,
+        // The declarations document no defaults for CreateSnippet; these mirror
+        // the built-in action Raycast renders.
+        title: rest.title ?? "Create Snippet",
+        icon: rest.icon ?? Icon.Snippets,
+        onAction: () => requestCapability("snippet.create", params),
+    });
+}
+export function CreateQuicklink(props) {
+    const { quicklink, ...rest } = props;
+    const params = {
+        link: quicklink.link,
+        ...(quicklink.name === undefined ? {} : { name: quicklink.name }),
+        ...(quicklink.icon === undefined ? {} : { icon: quicklink.icon }),
+    };
+    const application = applicationParam(quicklink.application);
+    if (application !== undefined)
+        params.application = application;
+    return createElement("Action.CreateQuicklink", {
+        ...rest,
+        title: rest.title ?? "Create Quicklink",
+        icon: rest.icon ?? Icon.Quicklink,
+        onAction: () => requestCapability("quicklink.create", params),
+    });
+}
+export function ToggleQuickLook(props) {
+    // Which file to preview is the client's business (the selected item carries
+    // it), so the capability carries no payload.
+    return createElement("Action.ToggleQuickLook", {
+        title: props.title ?? "Quick Look",
+        icon: props.icon ?? Icon.Eye,
+        shortcut: props.shortcut,
+        onAction: () => requestCapability("quicklook.toggle", {}),
+    });
+}
+// The server descriptor is the only payload: rebuilt from the declared fields
+// so nothing unserializable or unknown reaches the wire.
+function serverParam(server) {
+    if (typeof server !== "object" || server === null || Array.isArray(server)) {
+        throw new TypeError("Action.InstallMCPServer: server must be an object");
+    }
+    if (server.transport !== "stdio" && server.transport !== "sse") {
+        throw new TypeError('Action.InstallMCPServer: server.transport must be "stdio" or "sse"');
+    }
+    const params = {
+        name: server.name,
+        transport: server.transport,
+    };
+    if (server.icon !== undefined)
+        params["icon"] = server.icon;
+    if (server.description !== undefined)
+        params["description"] = server.description;
+    if (server.transport === "stdio") {
+        params["command"] = server.command;
+        if (server.args !== undefined)
+            params["args"] = server.args;
+        if (server.env !== undefined)
+            params["env"] = server.env;
+    }
+    else {
+        params["url"] = server.url;
+        if (server.headers !== undefined)
+            params["headers"] = server.headers;
+    }
+    return params;
+}
+/**
+ * Installs an MCP server. Blast runs no MCP client, so this is a capability:
+ * the host decides, and a headless run denies it unless granted.
+ */
+export function InstallMCPServer(props) {
+    const { server, ...rest } = props;
+    return createElement("Action.InstallMCPServer", {
+        ...rest,
+        title: rest.title ?? "Install MCP Server",
+        onAction: async () => {
+            await requestCapability("mcp.install", { server: serverParam(server) });
+        },
+    });
+}