@motiadev/workbench 0.13.0-beta.162-850424 → 0.13.0-beta.162-080298

package/dist/src/stores/use-app-tabs-store.d.ts

@@ -0,0 +1,16 @@
+export declare enum TabLocation {
+    TOP = "top",
+    BOTTOM = "bottom"
+}
+export type AppTab = {
+    id: string;
+    tabLabel: React.ElementType;
+    content: React.ElementType;
+};
+export interface AppTabsState {
+    tabs: Record<TabLocation, AppTab[]>;
+    addTab: (position: TabLocation, tab: AppTab) => void;
+    setTabs: (position: TabLocation, tabs: AppTab[]) => void;
+    removeTab: (position: TabLocation, id: string) => void;
+}
+export declare const useAppTabsStore: import("zustand").UseBoundStore<import("zustand").StoreApi<AppTabsState>>;

package/dist/src/stores/use-app-tabs-store.js

@@ -0,0 +1,31 @@
+import { create } from 'zustand';
+export var TabLocation;
+(function (TabLocation) {
+    TabLocation["TOP"] = "top";
+    TabLocation["BOTTOM"] = "bottom";
+})(TabLocation || (TabLocation = {}));
+const defaultTabs = {
+    [TabLocation.TOP]: [],
+    [TabLocation.BOTTOM]: [],
+};
+export const useAppTabsStore = create((set) => ({
+    tabs: defaultTabs,
+    addTab: (position, tab) => set((state) => ({
+        tabs: {
+            ...state.tabs,
+            [position]: [...state.tabs[position], tab],
+        },
+    })),
+    setTabs: (position, tabs) => set((state) => ({
+        tabs: {
+            ...state.tabs,
+            [position]: tabs,
+        },
+    })),
+    removeTab: (position, id) => set((state) => ({
+        tabs: {
+            ...state.tabs,
+            [position]: state.tabs[position].filter((tab) => tab.id !== id),
+        },
+    })),
+}));

package/dist/src/stores/use-flow-store.d.ts

@@ -0,0 +1,21 @@
+type UseFlowStore = {
+    selectedFlowId?: string;
+    selectFlowId: (flowId: string) => void;
+    clearSelectedFlowId: () => void;
+    flows: string[];
+    setFlows: (flows: string[]) => void;
+};
+export declare const useFlowStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<UseFlowStore>, "setState" | "persist"> & {
+    setState(partial: UseFlowStore | Partial<UseFlowStore> | ((state: UseFlowStore) => UseFlowStore | Partial<UseFlowStore>), replace?: false | undefined): unknown;
+    setState(state: UseFlowStore | ((state: UseFlowStore) => UseFlowStore), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<UseFlowStore, UseFlowStore, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: UseFlowStore) => void) => () => void;
+        onFinishHydration: (fn: (state: UseFlowStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<UseFlowStore, UseFlowStore, unknown>>;
+    };
+}>;
+export {};

package/dist/src/stores/use-flow-store.js

@@ -0,0 +1,16 @@
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+export const useFlowStore = create(persist((set) => ({
+    flows: [],
+    setFlows: (flows) => set({ flows }),
+    selectFlowId: (flowId) => set((state) => {
+        if (state.selectedFlowId === flowId) {
+            return state;
+        }
+        return { selectedFlowId: flowId };
+    }),
+    clearSelectedFlowId: () => set({ selectedFlowId: undefined }),
+}), {
+    name: 'motia-flow-storage',
+    storage: createJSONStorage(() => localStorage),
+}));

package/dist/src/stores/use-global-store.d.ts

@@ -0,0 +1,18 @@
+type UseGlobalStore = {
+    selectedEndpointId?: string;
+    selectEndpointId: (endpointId?: string) => void;
+};
+export declare const useGlobalStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<UseGlobalStore>, "setState" | "persist"> & {
+    setState(partial: UseGlobalStore | Partial<UseGlobalStore> | ((state: UseGlobalStore) => UseGlobalStore | Partial<UseGlobalStore>), replace?: false | undefined): unknown;
+    setState(state: UseGlobalStore | ((state: UseGlobalStore) => UseGlobalStore), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<UseGlobalStore, UseGlobalStore, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: UseGlobalStore) => void) => () => void;
+        onFinishHydration: (fn: (state: UseGlobalStore) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<UseGlobalStore, UseGlobalStore, unknown>>;
+    };
+}>;
+export {};

package/dist/src/stores/use-global-store.js

@@ -0,0 +1,12 @@
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+const select = (id, name) => (state) => {
+    return id ? (state[name] === id ? state : { ...state, [name]: id }) : { ...state, [name]: undefined };
+};
+export const useGlobalStore = create(persist((set) => ({
+    selectedEndpointId: undefined,
+    selectEndpointId: (endpointId) => set(select(endpointId, 'selectedEndpointId')),
+}), {
+    name: 'motia-global-storage',
+    storage: createJSONStorage(() => localStorage),
+}));

package/dist/src/stores/use-motia-config-store.d.ts

@@ -0,0 +1,12 @@
+interface MotiaConfig {
+    isDev: boolean;
+    isTutorialDisabled: boolean;
+}
+interface MotiaConfigState {
+    config: MotiaConfig | null;
+    isLoading: boolean;
+    error: Error | null;
+    fetchConfig: () => Promise<void>;
+}
+export declare const useMotiaConfigStore: import("zustand").UseBoundStore<import("zustand").StoreApi<MotiaConfigState>>;
+export {};

package/dist/src/stores/use-motia-config-store.js

@@ -0,0 +1,24 @@
+import { create } from 'zustand';
+export const useMotiaConfigStore = create((set, get) => ({
+    config: null,
+    isLoading: false,
+    error: null,
+    fetchConfig: async () => {
+        const { config, isLoading } = get();
+        if (isLoading || config)
+            return;
+        set({ isLoading: true, error: null });
+        try {
+            const response = await fetch('/__motia');
+            if (!response.ok) {
+                throw new Error(`Failed to fetch Motia config: ${response.statusText}`);
+            }
+            const data = await response.json();
+            set({ config: data, isLoading: false });
+        }
+        catch (error) {
+            console.error('Failed to fetch Motia config:', error);
+            set({ error: error, isLoading: false });
+        }
+    },
+}));

package/dist/src/stores/use-tabs-store.d.ts

@@ -0,0 +1,19 @@
+interface TabsState {
+    tab: Record<string, string>;
+    setTopTab: (tab: string) => void;
+    setBottomTab: (tab: string) => void;
+}
+export declare const useTabsStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<TabsState>, "setState" | "persist"> & {
+    setState(partial: TabsState | Partial<TabsState> | ((state: TabsState) => TabsState | Partial<TabsState>), replace?: false | undefined): unknown;
+    setState(state: TabsState | ((state: TabsState) => TabsState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<TabsState, TabsState, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: TabsState) => void) => () => void;
+        onFinishHydration: (fn: (state: TabsState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<TabsState, TabsState, unknown>>;
+    };
+}>;
+export {};

package/dist/src/stores/use-tabs-store.js

@@ -0,0 +1,22 @@
+import { create } from 'zustand';
+import { createJSONStorage, persist } from 'zustand/middleware';
+import { motiaAnalytics } from '@/lib/motia-analytics';
+export const useTabsStore = create(persist((set, get) => ({
+    tab: {
+        top: 'flow',
+        bottom: 'tracing',
+    },
+    setTopTab: (tab) => {
+        const currentTab = get().tab;
+        motiaAnalytics.track('Top panel tab changed', { 'new.top': tab, tab: currentTab });
+        set((state) => ({ tab: { ...state.tab, top: tab } }));
+    },
+    setBottomTab: (tab) => {
+        const currentTab = get().tab;
+        motiaAnalytics.track('Bottom panel tab changed', { 'new.bottom': tab, tab: currentTab });
+        set((state) => ({ tab: { ...state.tab, bottom: tab } }));
+    },
+}), {
+    name: 'motia-tabs-storage',
+    storage: createJSONStorage(() => localStorage),
+}));

package/dist/src/system-view-mode.d.ts

@@ -0,0 +1 @@
+export declare const SystemViewMode: import("react").MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;

package/dist/src/system-view-mode.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { APP_SIDEBAR_CONTAINER_ID, CollapsiblePanelGroup } from '@motiadev/ui';
+import { memo } from 'react';
+import { BottomPanel } from './components/bottom-panel';
+import { Header } from './components/header/header';
+import { TopPanel } from './components/top-panel';
+export const SystemViewMode = memo(() => {
+    return (_jsxs("div", { className: "grid grid-rows-[auto_1fr] grid-cols-[1fr_auto] bg-background text-foreground h-screen", children: [_jsx("div", { className: "col-span-2", children: _jsx(Header, {}) }), _jsx("main", { className: "m-2 overflow-hidden", children: _jsxs(CollapsiblePanelGroup, { autoSaveId: "app-panel", direction: "vertical", className: "gap-1 h-full", "aria-label": "Workbench panels", children: [_jsx(TopPanel, {}), _jsx(BottomPanel, {})] }) }), _jsx("div", { id: APP_SIDEBAR_CONTAINER_ID })] }));
+});
+SystemViewMode.displayName = 'SystemViewMode';

package/dist/src/types/endpoint.d.ts

@@ -0,0 +1,14 @@
+export type ApiRouteMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'OPTIONS' | 'HEAD';
+export type QueryParam = {
+    name: string;
+    description: string;
+};
+export type ApiEndpoint = {
+    id: string;
+    method: ApiRouteMethod;
+    path: string;
+    description?: string;
+    queryParams?: QueryParam[];
+    responseSchema?: Record<string, any>;
+    bodySchema?: Record<string, Record<string, any>>;
+};

package/dist/src/types/endpoint.js

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

package/dist/src/types/file.d.ts

@@ -0,0 +1,7 @@
+export type Feature = {
+    id?: string;
+    title: string;
+    description: string;
+    lines: string[];
+    link?: string;
+};

package/dist/src/types/file.js

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

package/dist/src/types/flow.d.ts

@@ -0,0 +1,115 @@
+import type { JSONSchema7 } from 'json-schema';
+export type EventNodeData = {
+    type: string;
+    name: string;
+    description?: string;
+    subscribes: string[];
+    emits: Array<string | {
+        topic: string;
+        label?: string;
+    }>;
+    virtualEmits?: Array<string | {
+        topic: string;
+        label?: string;
+    }>;
+    virtualSubscribes?: string[];
+    language?: string;
+};
+export type NoopNodeData = {
+    type: string;
+    name: string;
+    description?: string;
+    virtualEmits: string[];
+    subscribes: string[];
+};
+export type ApiNodeData = {
+    type: string;
+    name: string;
+    language?: string;
+    description?: string;
+    emits: Array<string | {
+        topic: string;
+        label?: string;
+    }>;
+    subscribes?: string[];
+    virtualEmits?: Array<string | {
+        topic: string;
+        label?: string;
+    }>;
+    virtualSubscribes?: string[];
+    webhookUrl?: string;
+    bodySchema?: JSONSchema7;
+};
+export type CronNodeData = {
+    type: string;
+    name: string;
+    description?: string;
+    emits: Array<string | {
+        topic: string;
+        label?: string;
+    }>;
+    virtualEmits?: Array<string | {
+        topic: string;
+        label?: string;
+    }>;
+    virtualSubscribes?: string[];
+    cronExpression: string;
+    language?: string;
+};
+export type NodeData = (EventNodeData | ApiNodeData | NoopNodeData | CronNodeData) & {
+    position?: {
+        x: number;
+        y: number;
+    };
+    filePath?: string;
+    nodeConfig?: {
+        sourceHandlePosition?: 'bottom' | 'right';
+        targetHandlePosition?: 'top' | 'left';
+    };
+};
+export type EdgeData = {
+    variant: 'event' | 'virtual';
+    label?: string;
+    labelVariant?: 'default' | 'conditional';
+};
+export type Emit = string | {
+    topic: string;
+    label?: string;
+};
+export type FlowStep = {
+    id: string;
+    name: string;
+    type: 'event' | 'api' | 'noop' | 'cron';
+    description?: string;
+    subscribes?: string[];
+    emits: Emit[];
+    virtualEmits?: Emit[];
+    action?: 'webhook';
+    webhookUrl?: string;
+    language?: string;
+    nodeComponentPath?: string;
+    filePath?: string;
+};
+export type FlowResponse = {
+    id: string;
+    name: string;
+    steps: FlowStep[];
+    edges: FlowEdge[];
+    error?: string;
+};
+export type FlowConfigResponse = {
+    id: string;
+    config: Record<string, NodeConfig>;
+};
+export type FlowEdge = {
+    id: string;
+    source: string;
+    target: string;
+    data: EdgeData;
+};
+export type NodeConfig = {
+    x: number;
+    y: number;
+    sourceHandlePosition?: 'bottom' | 'right';
+    targetHandlePosition?: 'top' | 'left';
+};

package/dist/src/types/flow.js

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