@moises.ai/extension 0.0.20 → 1.0.1

package/Readme.md

@@ -1,34 +1 @@
-# Moises Extensions SDK
-
-```jsx
-"use client"
-
-import { useEffect } from "react";
-import { initMoisesExtension, Button } from "@moises.ai/extension";
-
-const useMoisesExtension = initMoisesExtension({
-  id: "your-extension-id",
-  name: "Sample extension",
-  description: "A bit about this extension",
-  version: "1.0.0",
-  author: "Moises Systems Incs",
-});
-
-export default function Home() {
-  const { moises, ModalLayout, isConnected } = useMoisesExtension();
-
-  useEffect(() => {
-    if (!moises) {
-      return
-    }
-
-    moises.link("footer:menu", { label: "Audio Editor" }, async () => {
-      moises.ui.open({ mountPoint: "bottomPanel" });
-    })
-  }, [moises]);
-
-  return (
-    <Button onClick={() => moises.ui.alert({ title: "Hello", message: "World" })}>Click me</Button>
-  );
-}
-```
+# Moises Extensions SDK

package/dist/client-Bt6Snfq-.js

@@ -0,0 +1,108 @@
+class h {
+  constructor({ target: e }) {
+    this.target = e, this.handlers = /* @__PURE__ */ new Map(), this.pendingRequests = /* @__PURE__ */ new Map(), this.requestId = 0, this.connected = !1, this.boundHandler = this.handleMessage.bind(this), this.connect();
+  }
+  connect() {
+    window.addEventListener("message", this.boundHandler), this.connected = !0;
+  }
+  disconnect() {
+    window.removeEventListener("message", this.boundHandler);
+    for (const [e, { reject: s }] of this.pendingRequests.entries())
+      s(new Error("Connection closed")), this.pendingRequests.delete(e);
+    this.connected = !1;
+  }
+  handleMessage(e) {
+    const { data: s, source: t, origin: n } = e;
+    if (t === this.target) {
+      if (s.type === "response") {
+        const { requestId: r, result: d, error: o } = s, c = this.pendingRequests.get(r);
+        c && (o ? c.reject(new Error(o)) : c.resolve(d), this.pendingRequests.delete(r));
+        return;
+      }
+      if (s.type === "request") {
+        const { method: r, params: d, requestId: o } = s, c = this.handlers.get(r);
+        if (!c) {
+          this.sendResponse(t, o, null, `No handler for method: ${r}`);
+          return;
+        }
+        Promise.resolve().then(() => c(d)).then((a) => this.sendResponse(t, o, a)).catch((a) => this.sendResponse(t, o, null, a.message));
+      }
+    }
+  }
+  sendResponse(e, s, t, n = null) {
+    e.postMessage({
+      type: "response",
+      requestId: s,
+      result: t,
+      error: n
+    }, "*");
+  }
+  on(e, s) {
+    this.handlers.set(e, s);
+  }
+  off(e) {
+    this.handlers.delete(e);
+  }
+  once(e, s) {
+    const t = async (n) => (this.off(e), s(n));
+    this.on(e, t);
+  }
+  async call(e, s) {
+    const t = this.requestId++;
+    return new Promise((n, r) => {
+      this.pendingRequests.set(t, { resolve: n, reject: r }), this.target.postMessage({
+        type: "request",
+        method: e,
+        params: s,
+        requestId: t
+      }, "*");
+    });
+  }
+}
+class u {
+  constructor(e) {
+    this.rpc = new h(e), this.proxy = this.createProxy();
+  }
+  createProxy() {
+    return new Proxy(this.rpc, {
+      get: (e, s) => s in e ? e[s] : new Proxy({}, {
+        get: (t, n) => async (r) => {
+          const d = `${s}.${n}`;
+          return e.call(d, r);
+        }
+      })
+    });
+  }
+  // Proxy the on method to maintain the same interface
+  // on(method, handler) {
+  //   return this.rpc.on(method, handler);
+  // }
+}
+function l(i) {
+  const e = {
+    id: i.id,
+    name: i.name,
+    description: i.description,
+    icon: i.icon,
+    author: i.author,
+    version: i.version,
+    isLoaded: !1,
+    events: {}
+  }, { proxy: s, rpc: t } = new u({
+    target: window.parent
+  }), n = (
+    /** @type {any} */
+    s
+  );
+  return n.link = async (r, d, o) => {
+    const c = await n.register.link({ category: r, options: d });
+    t.on(`${c.id}`, o);
+  }, n.connect = async function() {
+    const r = n.register.extension(e);
+    return e.isLoaded = !0, r;
+  }, n.plugin = e, n;
+}
+export {
+  l as M,
+  h as R
+};

package/dist/client.js

@@ -0,0 +1,4 @@
+import { M as e } from "./client-Bt6Snfq-.js";
+export {
+  e as MoisesExtension
+};

package/dist/index.d.ts

@@ -0,0 +1,450 @@
+
+/** Controlling common UI elements */
+export interface UiApi {
+
+  /** Displays a progress bar or loading indicator */
+  progress: (options: {
+
+    /** Progress title */
+    title?: string;
+
+    /** Progress value (0-100) */
+    value?: number;
+  }) => Promise<void>;
+
+  /** Displays an alert to the user */
+  alert: (options: {
+
+    /** Alert title */
+    title?: string;
+
+    /** Alert description */
+    description?: string;
+
+    /** Alert CTA label */
+    ctaLabel?: string;
+
+    /** Alert CTA color */
+    ctaColor?: string;
+  }) => Promise<void>;
+
+  /** Displays a confirmation dialog */
+  confirm: (options: {
+
+    /** Confirmation title */
+    title: string;
+
+    /** Confirmation description */
+    description: string;
+
+    /** Confirmation CTA label */
+    ctaLabel?: string;
+
+    /** Confirmation CTA color */
+    ctaColor?: string;
+  }) => Promise<boolean>;
+
+  /** Displays a text input dialog */
+  prompt: (options: {
+
+    /** Prompt title */
+    title: string;
+
+    /** Prompt description */
+    description: string;
+
+    /** Prompt label */
+    label?: string;
+
+    /** Prompt default value */
+    defaultValue?: string;
+
+    /** Prompt CTA label */
+    ctaLabel?: string;
+
+    /** Prompt CTA color */
+    ctaColor?: string;
+  }) => Promise<string>;
+
+  /** Creates a panel in the interface */
+  panel: (options: {
+
+    /** Panel title */
+    title: string;
+
+    /** Panel content */
+    content?: string;
+  }) => Promise<any>;
+
+  /** Closes the extension */
+  close: () => Promise<void>;
+
+  /** Opens the extension */
+  open: (params: {
+
+    /** Location where the extension will be mounted */
+    mountPoint: string;
+  }) => Promise<void>;
+}
+
+
+/** Session API for managing audio sessions, tracks, and playback controls */
+export interface SessionApi {
+
+  /** Exports the audio from the current session */
+  export: () => Promise<any>;
+
+  /** Gets the list of tracks from the session */
+  tracks: () => Promise<any[]>;
+
+  /** Starts session playback */
+  play: () => void;
+
+  /** Pauses session playback */
+  pause: () => void;
+
+  /** Toggles between play and pause */
+  togglePlayback: () => void;
+
+  /** Clears the current selection in the session */
+  clearSelection: () => void;
+
+  /** Sets a selection in the session */
+  setSelection: (params: {
+
+    /** ID of the track to be selected */
+    trackId?: string;
+
+    /** Start position of the selection */
+    start: number;
+
+    /** End position of the selection */
+    end: number;
+  }) => void;
+}
+
+
+/** Track API for managing audio tracks */
+export interface TrackApi {
+
+  /** Gets a track by its ID */
+  get: (trackId: string) => Promise<any>;
+
+  /** Creates a new track */
+  create: (params: {
+
+    /** The ID of the group to add the track to */
+    groupId: string;
+
+    /** The audio data for the track */
+    arrayBuffer: any;
+
+    /** The name of the track */
+    name: string;
+
+    /** The start position of the track in seconds */
+    startPositionSec: number;
+  }) => Promise<any>;
+
+  /** Updates a track */
+  update: (params: {
+
+    /** The ID of the track to update */
+    trackId: string;
+
+    /** The audio data for the track */
+    arrayBuffer: any;
+
+    /** Additional options for the track */
+    options?: any;
+  }) => Promise<any>;
+
+  /** Deletes a track */
+  delete: (trackId: string) => Promise<any>;
+}
+
+
+/** Group API for managing audio groups */
+export interface GroupApi {
+
+  /** Creates a new group */
+  create: (params: {
+
+    /** The name of the group */
+    name: string;
+
+    /** The ID of the group */
+    id: string;
+
+    /** The type of the group */
+    type: string;
+
+    /** The order of the group */
+    order: number;
+
+    /** Whether the group is solo */
+    solo: boolean;
+
+    /** Whether the group is muted */
+    muted: boolean;
+
+    /** The pan of the group */
+    pan: number;
+
+    /** The volume of the group */
+    volume: number;
+
+    /** Additional options for the group */
+    options: any;
+  }) => Promise<any>;
+
+  /** Updates a group */
+  update: (params: {
+
+    /** The ID of the group to update */
+    groupId: string;
+
+    /** The name of the group */
+    name: string;
+
+    /** The type of the group */
+    type: string;
+
+    /** The order of the group */
+    order: number;
+
+    /** Whether the group is solo */
+    solo: boolean;
+
+    /** Whether the group is muted */
+    muted: boolean;
+
+    /** The pan of the group */
+    pan: number;
+
+    /** The volume of the group */
+    volume: number;
+  }) => Promise<any>;
+}
+
+
+/** Storage API for managing audio files */
+export interface StorageApi {
+
+  /** Uploads a buffer to the storage */
+  upload: (params: {
+
+    /** The audio data to upload */
+    buffer: any;
+  }) => Promise<any>;
+
+  /** Downloads an audio file from the storage */
+  download: (params: {
+
+    /** The URL of the audio file to download */
+    url: string;
+  }) => Promise<any>;
+}
+
+
+/** Compute API for managing audio computations */
+export interface ComputeApi {
+
+  /** Generates a session player */
+  sessionPlayerGenerate: (params: {
+
+    /** The context audio for the session player */
+    contextAudio: any;
+
+    /** The conditioning audio for the session player */
+    conditioningAudio: any;
+
+    /** The conditioning text for the session player */
+    conditioningText: string;
+
+    /** The number of steps for the session player */
+    steps: number;
+
+    /** The guidance scale for the session player */
+    guidanceScale: number;
+
+    /** The weight schedule for the session player */
+    weightSchedule: number;
+
+    /** The instrument for the session player */
+    instrument: string;
+
+    /** The preset ID for the session player */
+    presetId: string;
+
+    /** Whether to use chroma for the session player */
+    chroma: boolean;
+
+    /** The timestamps for the session player */
+    inpaintingTimestamps: any[];
+
+    /** The target for the session player */
+    inpaintingTarget: any[];
+  }) => Promise<void>;
+
+  /** Gets the list of session player presets */
+  sessionPlayerPresets: () => Promise<void>;
+
+  /** Inpaints an audio file */
+  sessionPlayerInpaint: (params: {
+
+    /** The input audio data */
+    input: any;
+
+    /** The mask for the inpainting */
+    mask: any;
+  }) => Promise<void>;
+
+  /** Runs a workflow */
+  workflow: (params: {
+
+    /** The ID of the workflow to run */
+    workflowId: string;
+
+    /** The parameters for the workflow TODO: add type */
+    params: any;
+  }) => Promise<void>;
+
+  /** Runs an automix job */
+  automix: (params: {
+
+    /** The ID of the workflow to run TODO: add type */
+    workflowId: string;
+
+    /** The parameters for the workflow TODO: add type */
+    params: any;
+  }) => Promise<void>;
+
+  /** Detects instruments in an audio file */
+  instruments: (params: {
+
+    /** The input audio data */
+    input: string;
+  }) => Promise<void>;
+
+  /** Detects chords in an audio file */
+  chords: (params: {
+
+    /** The input audio data */
+    input: string;
+  }) => Promise<void>;
+
+  /** Detects beats in an audio file */
+  beats: (params: {
+
+    /** The input audio data */
+    input: string;
+  }) => Promise<void>;
+
+  /** Detects sections in an audio file */
+  sections: (params: {
+
+    /** The input audio data */
+    input: string;
+  }) => Promise<void>;
+
+  /** Detects lyrics in an audio file */
+  lyrics: (params: {
+
+    /** The input audio data */
+    input: string;
+  }) => Promise<void>;
+
+  /** Extracts stems from an audio file */
+  stems: (params: {
+
+    /** The input audio data */
+    input: string;
+
+    /** The stems to extract */
+    stemsToExtract: any[];
+  }) => void;
+}
+
+
+/** Registration methods for extensions */
+export interface RegisterApi {
+
+  /** Register the extension with the parent application */
+  extension: (plugin: any) => any;
+
+  /** Register a link connection for data streaming */
+  link: (options: any) => any;
+}
+
+
+export interface MoisesAPI {
+  /** Controlling common UI elements */
+  ui: UiApi;
+  /** Session API for managing audio sessions, tracks, and playback controls */
+  session: SessionApi;
+  /** Track API for managing audio tracks */
+  track: TrackApi;
+  /** Group API for managing audio groups */
+  group: GroupApi;
+  /** Storage API for managing audio files */
+  storage: StorageApi;
+  /** Compute API for managing audio computations */
+  compute: ComputeApi;
+  /** Registration methods for extensions */
+  register: RegisterApi;
+  
+  /** Custom link method for easy connection setup (convenience wrapper around register.link) */
+  link: (category: string, options: any, cb: (data: any) => void) => Promise<void>;
+  
+  /** Function to connect the extension to the parent application */
+  connect: () => Promise<any>;
+  /** Plugin metadata and configuration */
+  plugin: any;
+}
+
+
+export interface ExtensionInstance {
+  /** Function to connect the extension to the parent application */
+  connect: () => Promise<any>;
+  /** Plugin metadata and configuration */
+  plugin: any;
+  /** API to control Moises */
+  api: MoisesAPI;
+}
+
+export interface MoisesHook {
+  /** The complete Moises API with all functionality */
+  moises: MoisesAPI;
+  /** Plugin instance information */
+  plugin: any;
+  /** Connection status */
+  isConnected: boolean;
+  /** Modal layout component for plugin UI */
+  ModalLayout: (props: { children: any; width?: number; height?: number; }) => any;
+}
+
+export interface ExtensionOptions {
+  /** Unique identifier for the extension */
+  id: string;
+  /** Display name of the extension */
+  name: string;
+  /** Description of what the extension does */
+  description: string;
+  /** Icon to represent the extension */
+  icon: string;
+  /** Author of the extension */
+  author?: string;
+  /** Version number of the extension */
+  version?: string;
+}
+
+/**
+ * Creates a new Moises Extension instance (internal client)
+ */
+export function MoisesExtension(options: ExtensionOptions): MoisesAPI;
+
+/**
+ * Initializes a Moises extension hook for React components
+ */
+export function initMoisesExtension(options: ExtensionOptions): () => MoisesHook;