@vicinae/api 0.3.0

package/dist/api/toast.d.ts

@@ -0,0 +1,168 @@
+import { Keyboard } from "./keyboard";
+/**
+ * A Toast with a certain style, title, and message.
+ *
+ * @example
+ * ```typescript
+ * import { showToast, Toast } from "@raycast/api";
+ * import { setTimeout } from "timers/promises";
+ *
+ * export default async () => {
+ *   const toast = await showToast({ style: Toast.Style.Animated, title: "Uploading image" });
+ *
+ *   await setTimeout(1000);
+ *
+ *   toast.style = Toast.Style.Success;
+ *   toast.title = "Uploaded image";
+ * };
+ * ```
+ */
+export declare class Toast {
+    private options;
+    private callbacks;
+    private id;
+    private styleMap;
+    /**
+     * Deprecated - Use `showToast` instead
+     */
+    constructor(props: Toast.Options);
+    /**
+     * The style of a Toast.
+     */
+    get style(): Toast.Style;
+    set style(style: Toast.Style);
+    /**
+     * The title of a Toast. Displayed on the top.
+     */
+    get title(): string;
+    set title(title: string);
+    /**
+     * An additional message for the Toast. Useful to show more information, e.g. an identifier of a newly created asset.
+     */
+    get message(): string | undefined;
+    set message(message: string | undefined);
+    /**
+     * The primary Action the user can take when hovering on the Toast.
+     */
+    get primaryAction(): Toast.ActionOptions | undefined;
+    set primaryAction(action: Toast.ActionOptions | undefined);
+    /**
+     * The secondary Action the user can take when hovering on the Toast.
+     */
+    get secondaryAction(): Toast.ActionOptions | undefined;
+    set secondaryAction(action: Toast.ActionOptions | undefined);
+    /**
+     * Shows the Toast.
+     *
+     * @returns A Promise that resolves when the toast is shown.
+     */
+    show(): Promise<void>;
+    /**
+     * Hides the Toast.
+     *
+     * @returns A Promise that resolves when toast is hidden.
+     */
+    hide(): Promise<void>;
+    private update;
+}
+export declare namespace Toast {
+    /**
+     * The options to create a {@link Toast}.
+     *
+     * @example
+     * ```typescript
+     * import { showToast, Toast } from "@raycast/api";
+     *
+     * export default async () => {
+     *   const options: Toast.Options = {
+     *     style: Toast.Style.Success,
+     *     title: "Finished cooking",
+     *     message: "Delicious pasta for lunch",
+     *     primaryAction: {
+     *       title: 'Do something',
+     *       onAction: () => {
+     *         console.log("The toast action has been triggered")
+     *       }
+     *     }
+     *   };
+     *   await showToast(options);
+     * };
+     * ```
+     */
+    interface Options {
+        /**
+         * The title of a Toast. Displayed on the top.
+         */
+        title: string;
+        /**
+         * An additional message for the Toast. Useful to show more information, e.g. an identifier of a newly created asset.
+         */
+        message?: string;
+        /**
+         * The style of a Toast.
+         */
+        style?: Style;
+        /**
+         * The primary Action the user can take when hovering on the Toast.
+         */
+        primaryAction?: ActionOptions;
+        /**
+         * The secondary Action the user can take when hovering on the Toast.
+         */
+        secondaryAction?: ActionOptions;
+    }
+    /**
+     * The options to create a {@link Toast} Action.
+     */
+    interface ActionOptions {
+        /**
+         * The title of the action.
+         */
+        title: string;
+        /**
+         * The keyboard shortcut for the action.
+         */
+        shortcut?: Keyboard.Shortcut;
+        /**
+         * A callback called when the action is triggered.
+         */
+        onAction: (toast: Toast) => void;
+    }
+    /**
+     * Defines the visual style of the Toast.
+     *
+     * @remarks
+     * Use {@link Toast.Style.Success} for confirmations and {@link Toast.Style.Failure} for displaying errors.
+     * Use {@link Toast.Style.Animated} when your Toast should be shown until a process is completed.
+     * You can hide it later by using {@link Toast.hide} or update the properties of an existing Toast.
+     */
+    enum Style {
+        Success = "success",
+        Failure = "failure",
+        Animated = "animated"
+    }
+}
+/**
+ * @deprecated Use {@link Toast.ActionOptions} instead
+ */
+export declare interface ToastActionOptions extends Toast.ActionOptions {
+}
+/**
+ * @deprecated Use {@link Toast.Options} instead
+ */
+export declare interface ToastOptions extends Toast.Options {
+}
+/**
+ * @deprecated Use {@link Toast.Style} instead
+ */
+export declare const ToastStyle: typeof Toast.Style;
+export declare const showToast: (init: Toast.Style | Toast.Options, title?: string, message?: string) => Promise<Toast>;
+export declare enum PopToRootType {
+    Default = "default",
+    Immediate = "immediate",
+    Suspended = "suspended"
+}
+export declare const showHUD: (title: string, options?: {
+    clearRootSearch?: boolean;
+    popToRootType?: PopToRootType;
+}) => Promise<void>;

package/dist/api/toast.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showHUD = exports.PopToRootType = exports.showToast = exports.Toast = void 0;
+const crypto_1 = require("crypto");
+const bus_1 = require("./bus");
+const ui_1 = require("./proto/ui");
+/**
+ * A Toast with a certain style, title, and message.
+ *
+ * @example
+ * ```typescript
+ * import { showToast, Toast } from "@raycast/api";
+ * import { setTimeout } from "timers/promises";
+ *
+ * export default async () => {
+ *   const toast = await showToast({ style: Toast.Style.Animated, title: "Uploading image" });
+ *
+ *   await setTimeout(1000);
+ *
+ *   toast.style = Toast.Style.Success;
+ *   toast.title = "Uploaded image";
+ * };
+ * ```
+ */
+class Toast {
+    options;
+    callbacks = {};
+    id;
+    styleMap = {
+        [Toast.Style.Success]: ui_1.ToastStyle.Success,
+        [Toast.Style.Failure]: ui_1.ToastStyle.Error,
+        [Toast.Style.Animated]: ui_1.ToastStyle.Dynamic
+    };
+    /**
+     * Deprecated - Use `showToast` instead
+     */
+    constructor(props) {
+        this.id = `toast_${(0, crypto_1.randomBytes)(16).toString('hex')}`;
+        this.options = {
+            title: props.title,
+            style: props.style ?? Toast.Style.Success,
+            message: props.message
+        };
+        if (props.primaryAction) {
+            const { onAction } = props.primaryAction;
+            this.options.primaryAction = props.primaryAction;
+            this.callbacks.primary = (0, bus_1.createHandler)(() => onAction(this));
+        }
+        if (props.secondaryAction) {
+            const { onAction } = props.secondaryAction;
+            this.options.secondaryAction = props.secondaryAction;
+            this.callbacks.secondary = (0, bus_1.createHandler)(() => onAction(this));
+        }
+    }
+    /**
+     * The style of a Toast.
+     */
+    get style() { return this.options.style; }
+    set style(style) { this.options.style = style; }
+    /**
+     * The title of a Toast. Displayed on the top.
+     */
+    get title() { return this.options.title; }
+    set title(title) { this.options.title = title; }
+    /**
+     * An additional message for the Toast. Useful to show more information, e.g. an identifier of a newly created asset.
+     */
+    get message() { return this.options.message; }
+    set message(message) { this.options.message = message; }
+    /**
+     * The primary Action the user can take when hovering on the Toast.
+     */
+    get primaryAction() { return this.options.primaryAction; }
+    set primaryAction(action) { this.options.primaryAction = action; }
+    /**
+     * The secondary Action the user can take when hovering on the Toast.
+     */
+    get secondaryAction() { return this.options.secondaryAction; }
+    set secondaryAction(action) { this.options.secondaryAction = action; }
+    /**
+     * Shows the Toast.
+     *
+     * @returns A Promise that resolves when the toast is shown.
+     */
+    async show() {
+        const payload = {
+            title: this.options.title,
+            message: this.options.message,
+            style: this.options.style,
+        };
+        if (this.options.primaryAction && this.callbacks.primary) {
+            const { title, shortcut } = this.options.primaryAction;
+            payload.primaryAction = {
+                title, shortcut, onAction: this.callbacks.primary
+            };
+        }
+        if (this.options.secondaryAction && this.callbacks.secondary) {
+            const { title, shortcut } = this.options.secondaryAction;
+            payload.secondaryAction = {
+                title, shortcut, onAction: this.callbacks.secondary
+            };
+        }
+        await bus_1.bus.turboRequest('ui.showToast', {
+            id: this.id,
+            title: payload.title,
+            style: this.styleMap[payload.style ?? Toast.Style.Success]
+        });
+    }
+    /**
+     * Hides the Toast.
+     *
+     * @returns A Promise that resolves when toast is hidden.
+     */
+    async hide() {
+        await bus_1.bus.turboRequest('ui.hideToast', { id: this.id });
+    }
+    update;
+}
+exports.Toast = Toast;
+(function (Toast) {
+    /**
+     * Defines the visual style of the Toast.
+     *
+     * @remarks
+     * Use {@link Toast.Style.Success} for confirmations and {@link Toast.Style.Failure} for displaying errors.
+     * Use {@link Toast.Style.Animated} when your Toast should be shown until a process is completed.
+     * You can hide it later by using {@link Toast.hide} or update the properties of an existing Toast.
+     */
+    let Style;
+    (function (Style) {
+        Style["Success"] = "success";
+        Style["Failure"] = "failure";
+        Style["Animated"] = "animated";
+    })(Style = Toast.Style || (Toast.Style = {}));
+})(Toast || (exports.Toast = Toast = {}));
+const showToast = async (init, title = "", message) => {
+    const toast = typeof init === 'string' ? new Toast({ style: init, message, title }) : new Toast(init);
+    await toast.show();
+    return toast;
+};
+exports.showToast = showToast;
+var PopToRootType;
+(function (PopToRootType) {
+    PopToRootType["Default"] = "default";
+    PopToRootType["Immediate"] = "immediate";
+    PopToRootType["Suspended"] = "suspended";
+})(PopToRootType || (exports.PopToRootType = PopToRootType = {}));
+;
+const showHUD = async (title, options) => {
+    await bus_1.bus.request('ui.show-hud', { title, options });
+};
+exports.showHUD = showHUD;

package/dist/api/utils.d.ts

@@ -0,0 +1,15 @@
+import { PathLike } from 'fs';
+export declare const captureException: (exception: unknown) => void;
+export declare const trash: (path: PathLike | PathLike[]) => Promise<void>;
+export declare const open: (target: string, app?: Application | string) => Promise<void>;
+export type Application = {
+    id: string;
+    name: string;
+    icon: {
+        iconName: string;
+    };
+};
+export declare const getFrontmostApplication: () => Promise<Application>;
+export declare const getApplications: (path?: PathLike) => Promise<Application[]>;
+export declare const getDefaultApplication: (path: PathLike) => Promise<Application>;
+export declare const showInFinder: (path: PathLike) => Promise<void>;

package/dist/api/utils.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showInFinder = exports.getDefaultApplication = exports.getApplications = exports.getFrontmostApplication = exports.open = exports.trash = exports.captureException = void 0;
+const promises_1 = require("fs/promises");
+const bus_1 = require("./bus");
+const captureException = (exception) => {
+    // maybe one day, if we have a developer hub, also...
+    console.error("captureException called on", exception);
+};
+exports.captureException = captureException;
+// Linux systems usually do not have a trash, but maybe we should support one...
+const trash = async (path) => {
+    const targets = Array.isArray(path) ? path : [path];
+    const promises = targets.map((p) => (0, promises_1.rm)(p, { recursive: true }));
+    await Promise.all(promises);
+};
+exports.trash = trash;
+const open = async (target, app) => {
+    let appId;
+    if (app) {
+        if (typeof app === 'string') {
+            appId = app;
+        }
+        else {
+            appId = app.id;
+        }
+    }
+    await bus_1.bus.turboRequest('app.open', {
+        target,
+        appId
+    });
+};
+exports.open = open;
+const deserializeApp = (app) => ({ id: app.id, name: app.name, icon: { iconName: app.icon } });
+const getFrontmostApplication = async () => {
+    const res = await bus_1.bus.request('apps.get-frontmost');
+    if (!res.data.app) {
+        throw new Error('couldnt get frontmost app');
+    }
+    return deserializeApp(res.data.app);
+};
+exports.getFrontmostApplication = getFrontmostApplication;
+const getApplications = async (path) => {
+    const res = await bus_1.bus.turboRequest('app.list', {});
+    if (!res.ok)
+        return [];
+    console.log('got turbo apps', { apps: res.value });
+    return [];
+};
+exports.getApplications = getApplications;
+const getDefaultApplication = async (path) => {
+    const res = await bus_1.bus.request('apps.get-default', {
+        target: path.toString()
+    });
+    if (!res.data.app) {
+        throw new Error('couldnt get default app');
+    }
+    return deserializeApp(res.data.app);
+};
+exports.getDefaultApplication = getDefaultApplication;
+const showInFinder = async (path) => {
+    await bus_1.bus.request('show-in-finder');
+};
+exports.showInFinder = showInFinder;

package/dist/commands/build/index.d.ts

@@ -0,0 +1,11 @@
+import { Command } from "@oclif/core";
+export default class Build extends Command {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        out: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        src: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/build/index.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const esbuild = __importStar(require("esbuild"));
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const logger_js_1 = require("../../utils/logger.js");
+const utils_js_1 = require("../../utils/utils.js");
+const manifest_js_1 = __importDefault(require("../../schemas/manifest.js"));
+class Build extends core_1.Command {
+    static args = {};
+    static description = "Start an extension development session";
+    static examples = [
+        `<%= config.bin %> <%= command.id %> --target /path/to/extension`,
+    ];
+    static flags = {
+        out: core_1.Flags.string({
+            aliases: ["output"],
+            char: "o",
+            description: "Path to output the compiled extension bundle to. Defaults to Vicinae extension directory.",
+            required: false,
+        }),
+        src: core_1.Flags.string({
+            aliases: ["src"],
+            char: "s",
+            default: process.cwd(),
+            defaultHelp: "The current working directory",
+            description: "Path to the extension source directory",
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Build);
+        const logger = new logger_js_1.Logger();
+        const src = flags.src ?? process.cwd();
+        const pkgPath = (0, node_path_1.join)(src, "package.json");
+        if (!(0, node_fs_1.existsSync)(pkgPath)) {
+            logger.logError(`No package.json found at ${pkgPath}. Does this location point to a valid extension repository?`);
+            process.exit(1);
+        }
+        const json = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, 'utf8'));
+        const e = manifest_js_1.default.safeParse(json);
+        if (e.error) {
+            logger.logError(`${pkgPath} is not a valid extension manifest: ${e.error}`);
+            process.exit(1);
+        }
+        const manifest = e.data;
+        const outDir = flags.out ?? (0, node_path_1.join)((0, utils_js_1.extensionDataDir)(), manifest.name);
+        const build = async (outDir) => {
+            const entryPoints = manifest.commands.map((cmd) => (0, node_path_1.join)("src", `${cmd.name}.tsx`));
+            logger.logInfo(`entrypoints [${entryPoints.join(", ")}]`);
+            const promises = manifest.commands.map((cmd) => {
+                const source = (0, node_path_1.join)(process.cwd(), "src", `${cmd.name}.tsx`);
+                return esbuild.build({
+                    bundle: true,
+                    entryPoints: [source],
+                    external: ["react", "@vicinae/api"],
+                    format: "cjs",
+                    outfile: (0, node_path_1.join)(outDir, `${cmd.name}.js`),
+                    platform: "node",
+                });
+            });
+            await Promise.all(promises);
+            const targetPkg = (0, node_path_1.join)(outDir, "package.json");
+            const targetAssets = (0, node_path_1.join)(outDir, "assets");
+            (0, node_fs_1.cpSync)("package.json", targetPkg, { force: true });
+            if ((0, node_fs_1.existsSync)("assets")) {
+                (0, node_fs_1.cpSync)("assets", targetAssets, { force: true, recursive: true });
+            }
+            else {
+                (0, node_fs_1.mkdirSync)(targetAssets, { recursive: true });
+            }
+        };
+        process.chdir(src);
+        logger.logInfo("Checking types...");
+        const typeCheck = (0, node_child_process_1.spawnSync)("npx", ["tsc", "--noEmit"]);
+        if (typeCheck.error) {
+            logger.logError(`Type check failed: ${typeCheck.error}`);
+            process.exit(1);
+        }
+        (0, node_fs_1.mkdirSync)(outDir, { recursive: true });
+        await build(outDir);
+        logger.logReady(`built extension successfully - output at ${outDir}`);
+    }
+}
+exports.default = Build;

package/dist/commands/develop/index.d.ts

@@ -0,0 +1,10 @@
+import { Command } from "@oclif/core";
+export default class Develop extends Command {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        target: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}