@micklsm/dot-workspace-components-sdk 0.1.0

package/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "@micklsm/dot-workspace-components-sdk",
+    "version": "0.1.0",
+    "main": "./src/index.js",
+    "types": "./src/index.d.ts",
+    "keywords": [
+        "sdk",
+        "dot workspace"
+    ],
+    "author": "micklsm",
+    "license": "MIT",
+    "description": "SDK for dot workspace component development",
+    "peerDependencies": {
+        "react": "^19.2.6",
+        "reactflow": "^11.11.4"
+    },
+    "devDependencies": {
+        "typescript": "^6.0.3"
+    },
+    "files": [
+        "./src/index.d.ts",
+        "./src/index.js"
+    ],
+    "scripts": {
+        "build": ""
+    },
+    "exports": {
+        ".": {
+            "types": "./src/index.d.ts"
+        }
+    }
+}

package/src/index.d.ts

@@ -0,0 +1,308 @@
+export interface WorkspaceAPIs {
+    node: {
+        create: (type: string, data: any, x: number, y: number) => NodeRuntime;
+        findById: (id: string) => NodeRuntime;
+        list: () => NodeRuntime[];
+    };
+    operations: {
+        create: (
+            name: string,
+            validate: OperationValidateDelegate,
+            execute: OperationExecuteDelegate,
+        ) => OperationRuntime;
+        findById: (id: string) => OperationRuntime;
+        list: () => OperationRuntime[];
+    };
+    functions: {
+        create: <TFunction extends AnyFunctionHandlerDelegate>(
+            name: string,
+            handler: TFunction,
+            tags: FunctionCapabilities[],
+            description: string,
+        ) => FunctionRuntime<TFunction>;
+        findByName: <TFunction extends AnyFunctionHandlerDelegate>(
+            id: string,
+        ) => FunctionRuntime<TFunction>;
+        list: () => FunctionRuntime<AnyFunctionHandlerDelegate>[];
+    };
+    workspace: {
+        saveNodes: () => Promise<void>;
+        saveConfigs: () => Promise<void>;
+
+        reloadComponents: () => Promise<void>;
+    };
+
+    // findFormById: (id: string) => FormRuntime;
+    // findComponentById: (id: string) => ComponentRuntime;
+    configs: ConfigurationRuntime;
+}
+export type NodeRendererDelegate = (
+    props: import("reactflow").NodeProps,
+) => import("react").JSX.Element;
+
+export interface RendererAPIs {
+    registerNodeRenderer(key: string, renderer: NodeRendererDelegate): void;
+    callFunction<TFunction extends AnyFunctionHandlerDelegate>(
+        key: string,
+        ...args: GetParameters<TFunction>
+    ): Promise<GetReturn<TFunction>>;
+}
+export interface NodeModel {
+    id: string;
+    x: number;
+    y: number;
+    data: any; //always a json object
+    type: string;
+}
+export interface WorkspaceModel {
+    nodes: NodeModel[];
+}
+export interface ConfigurationModel {
+    [name: string]: any;
+}
+export interface NodeRuntime {
+    get id(): string;
+    get data(): any;
+    set data(v: any);
+    get type(): string;
+    set type(v: string);
+    get x(): number;
+    set x(v: number);
+    get y(): number;
+    set y(v: number);
+
+    destroy(): void;
+}
+
+export interface ComponentMainProcessModule {
+    enable(apis: WorkspaceAPIs): void;
+    disable(apis: WorkspaceAPIs): void;
+}
+
+export interface OperationRuntime {
+    get id(): string;
+    get name(): string;
+    get namespace(): string;
+    validate: OperationValidateDelegate;
+    execute: OperationExecuteDelegate;
+    destroy(): void;
+}
+
+export interface ComponentRuntime {
+    get runtimeId(): string;
+    get name(): string;
+    get version(): string;
+    get requiredHostVersion(): string;
+    get description(): string;
+    get iconData(): string;
+    get readMe(): string;
+    get rendererCode(): string;
+    get isEnabled(): boolean;
+    enable(apis: WorkspaceAPIs): void;
+    disable(): void;
+    destroy(): void;
+}
+
+export interface FunctionRuntime<THandler extends AnyFunctionHandlerDelegate> {
+    get id(): string;
+    get name(): string;
+    get namespace(): string;
+    get capabilities(): string[];
+    get description(): string;
+
+    invoke(...args: GetParameters<THandler>): GetReturn<THandler>;
+    destroy(): void;
+}
+export interface FormRuntime {
+    get id(): string;
+    get name(): string;
+    get formSchema(): FormObjectSchema;
+    reply(response: FormResponse): void;
+    destroy(): void;
+}
+export interface WorkspaceRuntime {
+    loadNode(model: NodeModel): NodeRuntime;
+    get configurations(): ConfigurationRuntime;
+    createNode(type: string, data: any, x: number, y: number): NodeRuntime;
+    createOperation(
+        name: string,
+        namespace: string,
+        validate: OperationValidateDelegate,
+        execute: OperationExecuteDelegate,
+    ): OperationRuntime;
+    createFunction<TFunction extends AnyFunctionHandlerDelegate>(
+        name: string,
+        namespace: string,
+        handler: TFunction,
+        tags: string[],
+        description: string,
+    ): FunctionRuntime<TFunction>;
+    getAllNodes(): NodeRuntime[];
+    getAllOperations(): OperationRuntime[];
+    getAllFunctions(): FunctionRuntime[];
+    findNodeById(id: string): NodeRuntime;
+    findOperationById(id: string): OperationRuntime;
+    findFunctionByName<TFunction extends AnyFunctionHandlerDelegate>(
+        name: string,
+    ): FunctionRuntime<TFunction>;
+
+    saveWorkspace(): Promise<void>;
+    saveConfigurations(): Promise<void>;
+}
+
+export interface ConfigurationRuntime {
+    get data(): ConfigurationModel;
+    set data(): ConfigurationModel;
+}
+export type OperationValidateDelegate = (
+    client: WorkspaceUI,
+    nodes: NodeRuntime[],
+) => Promise<boolean>;
+export type OperationExecuteDelegate = (
+    client: WorkspaceUI,
+    nodes: NodeRuntime[],
+    x: number,
+    y: number,
+) => Promise<void>;
+export type WorkspaceFunctionHandlerDelegate<
+    TParameters extends any[],
+    TReturn extends any,
+> = (...args: TParameters) => TReturn;
+export type AnyFunctionHandlerDelegate = WorkspaceFunctionHandlerDelegate<
+    any[],
+    any
+>;
+export type GetParameters<T> =
+    T extends WorkspaceFunctionHandlerDelegate<infer P, any> ? P : never;
+export type GetReturn<T> =
+    T extends WorkspaceFunctionHandlerDelegate<any, infer R> ? R : never;
+
+export type UpdateNodeFunction = WorkspaceFunctionHandlerDelegate<
+    [node: NodeModel],
+    void
+>;
+export type ListNodesFunction = WorkspaceFunctionHandlerDelegate<
+    [],
+    NodeModel[]
+>;
+export type ReadNodeFunction = WorkspaceFunctionHandlerDelegate<
+    [nodeId: string],
+    NodeModel
+>;
+export type DeleteNodeFunction = WorkspaceFunctionHandlerDelegate<
+    [nodeId: string],
+    void
+>;
+export type SaveWorkspaceFunction = WorkspaceFunctionHandlerDelegate<[], void>;
+export type ReadConfigsFunction = WorkspaceFunctionHandlerDelegate<
+    [],
+    ConfigurationModel
+>;
+export type UpdateConfigsFunction = WorkspaceFunctionHandlerDelegate<
+    [newValue: ConfigurationModel],
+    void
+>;
+
+export type FunctionCapabilities =
+    | "incur-expenses"
+    | "sensitive-data"
+    | "dangerous";
+export interface IFormService {
+    sendForm(
+        name: string,
+        schema: FormObjectSchema,
+        listener: FormListenerDelegate,
+    ): void;
+}
+export interface INotificationService {
+    sendNotification(message: string): void;
+}
+export interface IUINodesService {
+    createNodeView(node: NodeModel): void;
+    updateNodeView(newValue: NodeModel): void;
+    deleteNodeView(id: string): void;
+}
+export interface ConfirmDialogOptions {
+    title: string;
+    message: string;
+    detail?: string;
+
+    options?: string[];
+
+    isDangerous: boolean;
+}
+export interface IDialogService {
+    confirm(options: ConfirmDialogOptions);
+}
+export interface IWindow {
+    get id(): number;
+    get type(): "workspace" | "configs-editor" | "components-manager";
+}
+export interface WorkspaceUI
+    extends INotificationService, IFormService, IDialogService {}
+export type WorkspaceNotification = NotificationMessage | NotificationProgress;
+export interface NotificationMessage {
+    type: "message";
+    id: string;
+    message: string;
+    state: "normal" | "success" | "fail" | "warning";
+}
+export interface NotificationProgress {
+    type: "progress";
+    id: string;
+    title: string;
+    message: string;
+    progress: {
+        current: number;
+        max: number;
+    };
+}
+export type FormResponse = FormCancelledResponse | FormRepliedResponse;
+export interface FormCancelledResponse {
+    action: "cancelled";
+}
+export interface FormRepliedResponse {
+    action: "replied";
+    data: any;
+}
+export type FormPropertiesSchema =
+    | FormStringSchema
+    | FormObjectSchema
+    | FormNumberSchema
+    | FormBooleanSchema;
+
+export interface FormStringSchema {
+    type: "string";
+    enums?: string[];
+}
+export interface FormNumberSchema {
+    type: "number";
+    max: number;
+    min: number;
+}
+export interface FormBooleanSchema {
+    type: "boolean";
+}
+
+export interface FormObjectSchema {
+    type: "object";
+    properties: {
+        [name: string]: FormPropertiesSchema;
+    };
+}
+export type FormListenerDelegate = (response: FormResponse) => void;
+export interface ComponentsManager {
+    loadComponentFor: (
+        name: string,
+        workspace: WorkspaceRuntime,
+    ) => Promise<ComponentRuntime>;
+    listAllLoadedComponents: () => ComponentRuntime[];
+    listAllInstalledComponentName: () => string[];
+}
+
+export interface ComponentManifest {
+    name: string;
+    version: string;
+    hostVersion: string;
+    description: string;
+}