@blastlauncher/runtime 1.0.5 → 3.0.0-alpha.1

package/dist/api/unsupported.generated.js

@@ -0,0 +1,56 @@
+// Generated by scripts/compat/generate-stubs.ts; do not edit.
+import * as implemented from "./implemented.js";
+import { createApi } from "./unsupported.js";
+const api = createApi(implemented);
+export const AI = api("AI");
+export const Action = api("Action");
+export const ActionPanel = api("ActionPanel");
+export const Alert = api("Alert");
+export const BrowserExtension = api("BrowserExtension");
+export const Cache = api("Cache");
+export const Clipboard = api("Clipboard");
+export const Color = api("Color");
+export const Detail = api("Detail");
+export const Form = api("Form");
+export const Grid = api("Grid");
+export const Icon = api("Icon");
+export const Keyboard = api("Keyboard");
+export const LaunchType = api("LaunchType");
+export const List = api("List");
+export const LocalStorage = api("LocalStorage");
+export const MenuBarExtra = api("MenuBarExtra");
+export const OAuth = api("OAuth");
+export const PopToRootType = api("PopToRootType");
+export const Toast = api("Toast");
+export const Tool = api("Tool");
+export const WindowManagement = api("WindowManagement");
+export const captureException = api("captureException");
+export const captureMemorySnapshot = api("captureMemorySnapshot");
+export const clearSearchBar = api("clearSearchBar");
+export const closeMainWindow = api("closeMainWindow");
+export const confirmAlert = api("confirmAlert");
+export const environment = api("environment");
+export const getApplications = api("getApplications");
+export const getDefaultApplication = api("getDefaultApplication");
+export const getFrontmostApplication = api("getFrontmostApplication");
+export const getPreferenceValues = api("getPreferenceValues");
+export const getSelectedFinderItems = api("getSelectedFinderItems");
+export const getSelectedText = api("getSelectedText");
+export const launchCommand = api("launchCommand");
+export const open = api("open");
+export const openCommandPreferences = api("openCommandPreferences");
+export const openExtensionPreferences = api("openExtensionPreferences");
+export const popToRoot = api("popToRoot");
+export const preferences = api("preferences");
+export const randomId = api("randomId");
+export const render = api("render");
+export const showHUD = api("showHUD");
+export const showInFinder = api("showInFinder");
+export const showToast = api("showToast");
+export const specialKeys = api("specialKeys");
+export const trash = api("trash");
+export const updateCommandMetadata = api("updateCommandMetadata");
+export const useActionPanel = api("useActionPanel");
+export const useId = api("useId");
+export const useNavigation = api("useNavigation");
+export const useUnstableAI = api("useUnstableAI");

package/dist/api/unsupported.js

@@ -0,0 +1,65 @@
+export class UnsupportedApiError extends Error {
+    code = "UNSUPPORTED_API";
+    path;
+    constructor(path) {
+        super(`Unsupported API in Blast: ${path}`);
+        this.name = "UnsupportedApiError";
+        this.path = path;
+    }
+}
+/** Present on stubs only: the unsupported path. Lets the serializer reject stub values. */
+export const UNSUPPORTED_PATH = Symbol.for("blast.unsupportedPath");
+export function unsupportedPath(value) {
+    if (typeof value !== "function" && (typeof value !== "object" || value === null))
+        return undefined;
+    const path = Reflect.get(value, UNSUPPORTED_PATH);
+    return typeof path === "string" ? path : undefined;
+}
+/** Preserve real implementations, while lazily supplying missing namespace members.
+ * Probe properties used by React and Promise resolution must retain normal semantics.
+ */
+export function withUnsupported(path, implemented) {
+    const target = implemented ??
+        function () {
+            throw new UnsupportedApiError(path);
+        };
+    if ((typeof target !== "object" || target === null) && typeof target !== "function")
+        return target;
+    const children = new Map();
+    const isStub = implemented === undefined;
+    return new Proxy(target, {
+        get(value, key, receiver) {
+            if (key === UNSUPPORTED_PATH)
+                return isStub ? path : undefined;
+            if (typeof key !== "string" ||
+                key === "then" ||
+                key === "prototype" ||
+                key.startsWith("_") ||
+                key.startsWith("$") ||
+                key === "displayName" ||
+                key === "defaultProps" ||
+                key === "contextTypes" ||
+                key === "childContextTypes" ||
+                key === "contextType" ||
+                key === "getDerivedStateFromProps" ||
+                key === "getDerivedStateFromError" ||
+                key === "propTypes" ||
+                key in Function.prototype)
+                return Reflect.get(value, key, receiver);
+            const child = Reflect.get(value, key, receiver);
+            if (key in value &&
+                (child === null || (typeof child !== "object" && typeof child !== "function")))
+                return child;
+            // A replaced or deleted member must not keep serving its old wrapper.
+            const cached = children.get(key);
+            if (cached && cached.source === child)
+                return cached.wrapper;
+            const wrapper = withUnsupported(`${path}.${key}`, child);
+            children.set(key, { source: child, wrapper });
+            return wrapper;
+        },
+    });
+}
+export function createApi(implemented) {
+    return (path) => withUnsupported(path, Reflect.get(implemented, path));
+}

package/dist/api/window-management.d.ts

@@ -0,0 +1,97 @@
+import type { Application } from "./open.js";
+/** `WindowManagement.DesktopType`, the enum generated from the declarations. */
+export declare const DesktopType: {
+    readonly User: "User";
+    readonly FullScreen: "FullScreen";
+};
+/** `WindowManagement.Desktop.type` as a value union. */
+export type DesktopTypeValue = (typeof DesktopType)[keyof typeof DesktopType];
+/** `WindowManagement.Desktop`: a virtual desktop on a screen. */
+export interface Desktop {
+    /** The size of the desktop. */
+    size: {
+        width: number;
+        height: number;
+    };
+    /** The unique identifier of the desktop. */
+    id: string;
+    /** The identifier of the screen the desktop is on. */
+    screenId: string;
+    /** Whether the desktop is the active one. */
+    active: boolean;
+    /** The kind of desktop. */
+    type: DesktopTypeValue;
+}
+/** The position and size of a window, as the declarations allow them partially. */
+export interface WindowBounds {
+    position?: {
+        x?: number;
+        y?: number;
+    };
+    size?: {
+        width?: number;
+        height?: number;
+    };
+}
+/** `WindowManagement.Window`: a window of an application on a desktop. */
+export interface Window {
+    /** The unique identifier of the window. */
+    id: string;
+    /** The application that owns the window, when the client can name it. */
+    application?: Application;
+    /** The bounds of the window, or `"fullscreen"`. */
+    bounds: {
+        position: {
+            x: number;
+            y: number;
+        };
+        size: {
+            width: number;
+            height: number;
+        };
+    } | "fullscreen";
+    /** The desktop the window is on. */
+    desktopId: string;
+    /** Whether the window can be made fullscreen. */
+    fullScreenSettable: boolean;
+    /** Whether the window can be resized. */
+    resizable: boolean;
+    /** Whether the window can be moved. */
+    positionable: boolean;
+    /** Whether the window is the active one. */
+    active: boolean;
+}
+/** `WindowManagement.setWindowBounds` options, exactly as the declarations union them. */
+export type SetWindowBoundsOptions = {
+    id: string;
+} & ({
+    bounds: WindowBounds;
+    desktopId?: string;
+} | {
+    bounds: "fullscreen";
+});
+/** Gets the desktops across all screens. */
+export declare function getDesktops(): Promise<Desktop[]>;
+/**
+ * Gets the active window. Rejects when no window is active, as the
+ * declarations promise.
+ */
+export declare function getActiveWindow(): Promise<Window>;
+/** Gets the windows on the active desktop. */
+export declare function getWindowsOnActiveDesktop(): Promise<Window[]>;
+/**
+ * Moves a window, or makes it fullscreen. The request reaches the host only
+ * through the capability, never the scene.
+ */
+export declare function setWindowBounds(options: SetWindowBoundsOptions): Promise<void>;
+/** Members in the order the declarations list them. */
+export declare const WindowManagement: {
+    DesktopType: {
+        readonly User: "User";
+        readonly FullScreen: "FullScreen";
+    };
+    getDesktops: typeof getDesktops;
+    getActiveWindow: typeof getActiveWindow;
+    getWindowsOnActiveDesktop: typeof getWindowsOnActiveDesktop;
+    setWindowBounds: typeof setWindowBounds;
+};

package/dist/api/window-management.js

@@ -0,0 +1,164 @@
+import { WindowManagement as WindowManagementEnums } from "./enums.generated.js";
+import { requestCapability } from "./capability.js";
+import { toApplication } from "./applications.js";
+/** `WindowManagement.DesktopType`, the enum generated from the declarations. */
+export const DesktopType = WindowManagementEnums.DesktopType;
+function numberField(value, at) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new TypeError(`${at} must be a finite number`);
+    }
+    return value;
+}
+function boundsWire(bounds, at) {
+    if (typeof bounds !== "object" || bounds === null || Array.isArray(bounds)) {
+        throw new TypeError(`${at}: bounds must be an object or "fullscreen"`);
+    }
+    const wire = {};
+    if (bounds.position !== undefined) {
+        const position = {};
+        const x = numberField(bounds.position.x, `${at}: bounds.position.x`);
+        const y = numberField(bounds.position.y, `${at}: bounds.position.y`);
+        if (x !== undefined)
+            position["x"] = x;
+        if (y !== undefined)
+            position["y"] = y;
+        wire["position"] = position;
+    }
+    if (bounds.size !== undefined) {
+        const size = {};
+        const width = numberField(bounds.size.width, `${at}: bounds.size.width`);
+        const height = numberField(bounds.size.height, `${at}: bounds.size.height`);
+        if (width !== undefined)
+            size["width"] = width;
+        if (height !== undefined)
+            size["height"] = height;
+        wire["size"] = size;
+    }
+    return wire;
+}
+// The host is another process: rebuild each value from the declared fields
+// rather than trusting whatever shape arrived on the wire.
+function toBounds(value, at) {
+    if (value === "fullscreen")
+        return value;
+    const bounds = boundsWire(value, at);
+    const { position, size } = bounds;
+    if (position?.x === undefined ||
+        position.y === undefined ||
+        size?.width === undefined ||
+        size.height === undefined) {
+        throw new TypeError(`${at}: the host returned incomplete Window bounds`);
+    }
+    return {
+        position: { x: position.x, y: position.y },
+        size: { width: size.width, height: size.height },
+    };
+}
+function toWindow(value, api) {
+    if (typeof value !== "object" ||
+        value === null ||
+        Array.isArray(value) ||
+        typeof value.id !== "string" ||
+        typeof value.desktopId !== "string" ||
+        typeof value.fullScreenSettable !== "boolean" ||
+        typeof value.resizable !== "boolean" ||
+        typeof value.positionable !== "boolean" ||
+        typeof value.active !== "boolean") {
+        throw new TypeError(`${api}: the host returned an invalid Window`);
+    }
+    const window = {
+        id: value.id,
+        bounds: toBounds(value.bounds, `${api}: bounds`),
+        desktopId: value.desktopId,
+        fullScreenSettable: value.fullScreenSettable,
+        resizable: value.resizable,
+        positionable: value.positionable,
+        active: value.active,
+    };
+    if (value.application !== undefined) {
+        window.application = toApplication(value.application, `${api}: application`);
+    }
+    return window;
+}
+function toDesktop(value, api) {
+    if (typeof value !== "object" ||
+        value === null ||
+        Array.isArray(value) ||
+        typeof value.id !== "string" ||
+        typeof value.screenId !== "string" ||
+        typeof value.active !== "boolean" ||
+        (value.type !== DesktopType.User && value.type !== DesktopType.FullScreen)) {
+        throw new TypeError(`${api}: the host returned an invalid Desktop`);
+    }
+    const size = value.size;
+    if (typeof size !== "object" ||
+        size === null ||
+        Array.isArray(size) ||
+        typeof size.width !== "number" ||
+        typeof size.height !== "number" ||
+        !Number.isFinite(size.width) ||
+        !Number.isFinite(size.height)) {
+        throw new TypeError(`${api}: the host returned an invalid Desktop size`);
+    }
+    return {
+        size: { width: size.width, height: size.height },
+        id: value.id,
+        screenId: value.screenId,
+        active: value.active,
+        type: value.type,
+    };
+}
+function windows(value, api) {
+    if (!Array.isArray(value))
+        throw new TypeError(`${api}: the host returned a non-array`);
+    return value.map((item) => toWindow(item, api));
+}
+/** Gets the desktops across all screens. */
+export async function getDesktops() {
+    const value = await requestCapability("window.desktops", {});
+    if (!Array.isArray(value))
+        throw new TypeError("getDesktops: the host returned a non-array");
+    return value.map((item) => toDesktop(item, "getDesktops"));
+}
+/**
+ * Gets the active window. Rejects when no window is active, as the
+ * declarations promise.
+ */
+export async function getActiveWindow() {
+    return toWindow(await requestCapability("window.active", {}), "getActiveWindow");
+}
+/** Gets the windows on the active desktop. */
+export async function getWindowsOnActiveDesktop() {
+    return windows(await requestCapability("window.list", {}), "getWindowsOnActiveDesktop");
+}
+/**
+ * Moves a window, or makes it fullscreen. The request reaches the host only
+ * through the capability, never the scene.
+ */
+export async function setWindowBounds(options) {
+    if (typeof options.id !== "string" || options.id === "") {
+        throw new TypeError("setWindowBounds: id must be a non-empty string");
+    }
+    const params = { id: options.id };
+    if (options.bounds === "fullscreen")
+        params["bounds"] = "fullscreen";
+    else
+        params["bounds"] = boundsWire(options.bounds, "setWindowBounds");
+    const desktopId = "desktopId" in options ? options.desktopId : undefined;
+    if (desktopId !== undefined) {
+        if (typeof desktopId !== "string")
+            throw new TypeError("setWindowBounds: desktopId must be a string");
+        params["desktopId"] = desktopId;
+    }
+    await requestCapability("window.setBounds", params);
+}
+/** Members in the order the declarations list them. */
+export const WindowManagement = {
+    DesktopType,
+    getDesktops,
+    getActiveWindow,
+    getWindowsOnActiveDesktop,
+    setWindowBounds,
+};

package/dist/api/window.d.ts

@@ -0,0 +1,16 @@
+import { PopToRootType } from "./enums.generated.js";
+export { PopToRootType };
+/** `PopToRootType`'s value union: the enum type from the declarations. */
+export type PopToRootTypeValue = (typeof PopToRootType)[keyof typeof PopToRootType];
+/** The `closeMainWindow` options from the declarations. */
+export interface CloseMainWindowOptions {
+    /** Asks the client to clear the root search bar and scroll to the top. */
+    clearRootSearch?: boolean;
+    popToRootType?: PopToRootTypeValue;
+}
+/** Scene subscription; `Navigation` renders `closeMainWindow` from the request. */
+export declare function subscribeCloseRequest(listener: () => void): () => void;
+/** The recorded request, or `undefined` while the window stays open. */
+export declare function closeRequest(): CloseMainWindowOptions | undefined;
+/** Records the request on the scene and resolves once it is published. */
+export declare function closeMainWindow(options?: CloseMainWindowOptions): Promise<void>;

package/dist/api/window.js

@@ -0,0 +1,32 @@
+// `closeMainWindow` from the declarations. Closing the window is a client
+// action, so the runtime records the request on the root `Navigation` scene
+// node (decision 0001, like HUD in decision 0004) and resolves. A no-view
+// command mounts its scene on the first request, exactly like feedback.
+import { PopToRootType } from "./enums.generated.js";
+import { mountScene } from "./feedback.js";
+export { PopToRootType };
+// Module state, not provider state: a no-view command has no mounted scene yet
+// when it closes the window, and its scene reads the request as it mounts.
+let request;
+const listeners = new Set();
+/** Scene subscription; `Navigation` renders `closeMainWindow` from the request. */
+export function subscribeCloseRequest(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+        // The scene is gone with its last subscriber, so a later command is clean.
+        if (listeners.size === 0)
+            request = undefined;
+    };
+}
+/** The recorded request, or `undefined` while the window stays open. */
+export function closeRequest() {
+    return request;
+}
+/** Records the request on the scene and resolves once it is published. */
+export async function closeMainWindow(options = {}) {
+    request = { ...options };
+    for (const listener of listeners)
+        listener();
+    mountScene();
+}

package/dist/main.d.ts

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