monday-sdk-js 0.4.12 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "monday-sdk-js",
-  "version": "0.4.12",
+  "version": "0.5.0",
   "private": false,
   "repository": "https://github.com/mondaycom/monday-sdk-js",
   "main": "src/index.js",
@@ -19,6 +19,7 @@
     "node-fetch": "^2.6.0"
   },
   "devDependencies": {
+    "monday-ui-react-core": "^2.63.2",
     "@babel/cli": "^7.6.0",
     "@babel/core": "^7.6.0",
     "@babel/node": "^7.6.1",

package/types/client-context.type.ts

@@ -0,0 +1,238 @@
+import type { Theme } from "monday-ui-react-core/dist/types/components/ThemeProvider/ThemeProviderConstants";
+
+type User = {
+  id: string;
+  isAdmin: boolean;
+  isGuest: boolean;
+  isViewOnly: boolean;
+  countryCode: string;
+  currentLanguage: string;
+  timeFormat: string;
+  timeZoneOffset: number;
+};
+
+type Account = {
+  id: string;
+};
+
+type App = {
+  id: number;
+  clientId: string;
+};
+
+type AppVersion = {
+  id: number;
+  name: string;
+  status: string;
+  type: string;
+  versionData: {
+    major: number;
+    minor: number;
+    patch: number;
+    type: string;
+  };
+};
+
+export type BaseContext = {
+  themeConfig?: Theme;
+  theme: string;
+  account: Account;
+  user: User;
+  region: string;
+  app: App;
+  appVersion: AppVersion;
+};
+
+export type AppFeatureBoardViewContext = BaseContext & {
+  boardId: number;
+  boardIds: number[];
+  boardViewId: number;
+  viewMode: string;
+  instanceId: number;
+  instanceType: string;
+  workspaceId: number;
+};
+
+export type AppFeatureAiBoardMainMenuHeaderContext = BaseContext & {
+  location: string;
+  locationContext: {
+    boardId: number;
+    workspaceId: number;
+  };
+  appFeatureId: number;
+  withExternalWidth: boolean;
+  withHeaderPadding: boolean;
+  boardId: number;
+  workspaceId: number;
+};
+
+export type AppFeatureDashboardWidgetContext = BaseContext & {
+  boardIds: number[];
+  widgetId: number;
+  viewMode: string;
+  editMode: boolean;
+  instanceId: number;
+  instanceType: string;
+};
+
+export type AppFeatureItemMenuActionContext = BaseContext & {
+  boardId: number;
+  pulseId: number;
+  itemId: number;
+};
+
+export type AppFeatureItemBatchActionContext = BaseContext & {
+  boardId: number;
+  itemId: number;
+  selectedPulsesIds: number[];
+};
+
+export type AppFeatureGroupMenuActionContext = BaseContext & {
+  groupId: string;
+  boardId: number;
+  groupColor: string;
+};
+
+export type AppFeatureObjectContext = BaseContext & {
+  boardId: number;
+  boardIds: [number];
+  workspaceId: number;
+  appFeatureId: number;
+  instanceId: number;
+  instanceType: string;
+  isFullScreen: boolean;
+  isPresentingMode: boolean;
+  objectPermissions: string;
+  isFirstLevelControlPinned: boolean;
+  isSlidePanelOpen: boolean;
+  boardLoadingState: number;
+};
+
+export type AppFeatureWorkspaceViewContext = BaseContext & {
+  workspaceId: number;
+};
+
+export type AppFeatureItemViewContext = BaseContext & {
+  workspaceId: number;
+  boardId: number;
+  boardIds: [number];
+  itemId: number;
+  instanceId: number;
+  instanceType: string;
+};
+
+export type AppFeatureAiDocQuickStartType = BaseContext & {
+  location: string;
+  locationContext: {
+    docId: number;
+    objectId: number;
+    workspaceId: number;
+    additionalSdkMethodsList: string[];
+  };
+  appFeatureId: number;
+  withExternalWidth: boolean;
+  withHeaderPadding: boolean;
+  docId: number;
+  objectId: number;
+  workspaceId: number;
+  additionalSdkMethodsList: string[];
+};
+
+export type AppFeatureAiDocTopBarContext = BaseContext & {
+  location: string;
+  locationContext: {
+    input: string;
+    docId: number;
+    objectId: number;
+    workspaceId: number;
+    additionalSdkMethodsList: string[];
+  };
+  appFeatureId: number;
+  withExternalWidth: boolean;
+  withHeaderPadding: boolean;
+  input: string;
+  docId: number;
+  objectId: number;
+  workspaceId: number;
+  additionalSdkMethodsList: string[];
+};
+export type FocusedBlock = {
+  id: string;
+  createdUserId: number;
+  accountId: number;
+  docId: number;
+  type: string;
+  content: {
+    alignment: string;
+    direction: string;
+    deltaFormat: Array<{
+      insert: string;
+    }>;
+    base64Encoded: string;
+  };
+  position: number;
+  parentBlockId: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type AppFeatureAiDocSlashCommandContext = BaseContext & {
+  location: string;
+  locationContext: {
+    focusedBlocks: FocusedBlock[];
+    canMoveToNextSelectedTextualBlock: boolean;
+    canMoveToPrevSelectedTextualBlock: boolean;
+    input: string;
+    isTextSelectedInBlock: boolean;
+    docId: number;
+    objectId: number;
+    workspaceId: number;
+    additionalSdkMethodsList: string[];
+  };
+  appFeatureId: number;
+  withExternalWidth: boolean;
+  withHeaderPadding: boolean;
+  focusedBlocks: FocusedBlock[];
+  canMoveToNextSelectedTextualBlock: boolean;
+  canMoveToPrevSelectedTextualBlock: boolean;
+  input: string;
+  isTextSelectedInBlock: boolean;
+  docId: number;
+  objectId: number;
+  workspaceId: number;
+  additionalSdkMethodsList: string[];
+};
+
+export type AppFeatureDocActionsContext = BaseContext & {
+  themeConfig: Theme;
+  docId: number;
+  objectId: number;
+  workspaceId: number;
+  focusedBlocks: FocusedBlock[];
+  placement: string;
+  highlightedText: string;
+  range: {
+    index: number;
+    length: number;
+  };
+  blockId: string;
+};
+
+export type AppFeatureContextMap = {
+  Base: BaseContext;
+  AppFeatureBoardView: AppFeatureBoardViewContext;
+  AppFeatureAiBoardMainMenuHeader: AppFeatureAiBoardMainMenuHeaderContext;
+  AppFeatureDashboardWidget: AppFeatureDashboardWidgetContext;
+  AppFeatureItemMenuAction: AppFeatureItemMenuActionContext;
+  AppFeatureItemBatchAction: AppFeatureItemBatchActionContext;
+  AppFeatureGroupMenuAction: AppFeatureGroupMenuActionContext;
+  AppFeatureObject: AppFeatureObjectContext;
+  AppFeatureWorkspaceView: AppFeatureWorkspaceViewContext;
+  AppFeatureItemView: AppFeatureItemViewContext;
+  AppFeatureAiDocQuickStart: AppFeatureAiDocQuickStartType;
+  AppFeatureAiDocTopBar: AppFeatureAiDocTopBarContext;
+  AppFeatureAiDocSlashCommand: AppFeatureAiDocSlashCommandContext;
+  AppFeatureDocActions: AppFeatureDocActionsContext;
+};
+
+export type AppFeatureTypes = keyof AppFeatureContextMap;

package/types/client-data.interface.ts

@@ -1,136 +1,155 @@
-type SubscribableEvents = 'context' | 'settings' | 'itemIds' | 'events';
+import { AppFeatureContextMap, AppFeatureTypes } from "./client-context.type";
 
-type SettableTypes = 'settings';
+type SubscribableEventsResponse<AppFeatureType extends AppFeatureTypes = AppFeatureTypes> = {
+  context: AppFeatureContextMap[AppFeatureType];
+  settings: Record<string, any>;
+  itemIds: number[];
+  events: Record<string, any>;
+};
+
+type SubscribableEvents = keyof SubscribableEventsResponse;
+
+type SettableTypes = "settings";
 
 interface GetResponse {
-    data: {
-        success: boolean;
-        value: any;
-        version?: any;
-    };
-    errorMessage?: string | undefined;
-    method: string;
-    requestId: string;
-    type?: string | undefined;
+  data: {
+    success: boolean;
+    value: any;
+    version?: any;
+  };
+  errorMessage?: string | undefined;
+  method: string;
+  requestId: string;
+  type?: string | undefined;
 }
 
 interface DeleteResponse {
-    data: {
-        success: boolean;
-        value: any;
-    };
-    errorMessage?: string | undefined;
-    method: string;
-    requestId: string;
-    type?: string | undefined;
+  data: {
+    success: boolean;
+    value: any;
+  };
+  errorMessage?: string | undefined;
+  method: string;
+  requestId: string;
+  type?: string | undefined;
 }
 
 interface SetResponse {
-    data: {
-        success: boolean;
-        version: string;
-        reason?: string | undefined;
-        error?: string | undefined;
-    };
-    errorMessage?: string | undefined;
-    requestId: string;
-    method: string;
-    type?: string | undefined;
+  data: {
+    success: boolean;
+    version: string;
+    reason?: string | undefined;
+    error?: string | undefined;
+  };
+  errorMessage?: string | undefined;
+  requestId: string;
+  method: string;
+  type?: string | undefined;
 }
 
-
+export type GetterResponse<AppFeatureType extends AppFeatureTypes = AppFeatureTypes> = {
+  context: AppFeatureContextMap[AppFeatureType];
+  settings: Record<string, any>;
+  itemIds: number[];
+  sessionToken: string;
+};
 export interface ClientData {
-    /**
-     * Used for retrieving data from the parent monday.com application where your app is currently running.
-     * This object can only be used when your app is running inside an `iframe`. This can only be used in client-side apps.
-     * @param type The type of requested information (available values below)
-     * - `'context'` Information about where this app is currently displayed, depending on the type of feature
-     * - `'settings'` The application settings as configured by the user that installed the app
-     * - `'itemIds'` The list of item IDs that are filtered in the current board (or all items if no filters are applied)
-     * - `'sessionToken'` A JWT token which is decoded with your app's secret and can be used as a session token between your app's frontend & backend
-     * - `'filter'` The state of the search filter
-     * - `'location'` The URL location within an app
-     * @param params Reserved for future use
-     */
-    get(type: 'context' | 'settings' | 'itemIds' | 'sessionToken' | 'filter' | 'location', params?: object): Promise<any>;
+  /**
+   * Used for retrieving data from the parent monday.com application where your app is currently running.
+   * This object can only be used when your app is running inside an `iframe`. This can only be used in client-side apps.
+   * @param type The type of requested information (available values below)
+   * - `'context'` Information about where this app is currently displayed, depending on the type of feature
+   * - `'settings'` The application settings as configured by the user that installed the app
+   * - `'itemIds'` The list of item IDs that are filtered in the current board (or all items if no filters are applied)
+   * - `'sessionToken'` A JWT token which is decoded with your app's secret and can be used as a session token between your app's frontend & backend
+   * @param params Reserved for future use
+   */
+  get<
+    CustomResponse,
+    T extends keyof GetterResponse = keyof GetterResponse,
+    AppFeatureType extends AppFeatureTypes = AppFeatureTypes
+  >(
+    type: T,
+    params?: object & { appFeatureType?: AppFeatureType }
+  ): Promise<GetterResponse<AppFeatureType>[T] & CustomResponse>;
+
+  /**
+   * Creates a listener which allows subscribing to certain types of client-side events.
+   * @param typeOrTypes The type, or array of types, of events to subscribe to
+   * @param callback A callback function that is fired when the listener is triggered by a client-side event
+   * @param params Reserved for future use
+   */
+  listen<
+    CustomResponse,
+    T extends SubscribableEvents = SubscribableEvents,
+    AppFeatureType extends AppFeatureTypes = AppFeatureTypes
+  >(
+    typeOrTypes: T | ReadonlyArray<T>,
+    callback: (res: { data: SubscribableEventsResponse<AppFeatureType>[T] & CustomResponse }) => void,
+    params?: object & { appFeatureType?: AppFeatureType }
+  ): void;
 
+  /**
+   * Set data in your application, such as updating settings
+   * @param type The type of data that can be set
+   * @param params object containing the data you want to update
+   */
+  set(type: SettableTypes, params: object): Promise<any>;
 
+  /**
+   * The Storage API is in early beta stages, its API is likely to change
+   *
+   * The monday apps infrastructure includes a persistent, key-value database storage that developers
+   * can leverage to store data without having to create their own backend and maintain their own database.
+   *
+   * The database currently offers instance-level storage only, meaning that each application instance (i.e. a single board view or a dashboard widget) maintains its own storage.
+   * Apps cannot share storage across accounts or even across apps installed in the same location.
+   */
+  storage: {
     /**
-     * Creates a listener which allows subscribing to certain types of client-side events.
-     * @param typeOrTypes The type, or array of types, of events to subscribe to
-     * @param callback A callback function that is fired when the listener is triggered by a client-side event
-     * @param params Reserved for future use
+     * Returns a stored value from the database under `key` for the app (**without any reference to the instance**)
+     * @param {string} key - Used to access to stored data
      */
-    listen(
-        typeOrTypes: SubscribableEvents | ReadonlyArray<SubscribableEvents>,
-        callback: (res: { data: object }) => void,
-        params?: object,
-    ): void;
-    
+    getItem(key: string): Promise<GetResponse>;
+
     /**
-     * Set data in your application, such as updating settings
-     * @param type The type of data that can be set
-     * @param params object containing the data you want to update
+     * Deletes a stored value from the database under `key` for the app (**without any reference to the instance**)
+     * @param {string} key - Used to delete the stored data
      */
-    set(
-        type: SettableTypes,
-        params: object,
-    ): Promise<any>;
+    deleteItem(key: string): Promise<DeleteResponse>;
 
     /**
-     * The Storage API is in early beta stages, its API is likely to change
-     *
-     * The monday apps infrastructure includes a persistent, key-value database storage that developers
-     * can leverage to store data without having to create their own backend and maintain their own database.
-     *
-     * The database currently offers instance-level storage only, meaning that each application instance (i.e. a single board view or a dashboard widget) maintains its own storage.
-     * Apps cannot share storage across accounts or even across apps installed in the same location.
+     * Stores `value` under `key` in the database for the app  (**without any reference to the instance**)
+     * @param {string} key - Used to delete the stored data
+     * @param {any} value - The value to store
+     * @param {object=} options
+     * @param {string=} options.previous_version - Use the new version of the storage (instance-less)
      */
-    storage: {
-        /**
-         * Returns a stored value from the database under `key` for the app (**without any reference to the instance**)
-         * @param {string} key - Used to access to stored data
-         */
-        getItem(key: string): Promise<GetResponse>;
-        
-        /**
-         * Deletes a stored value from the database under `key` for the app (**without any reference to the instance**)
-         * @param {string} key - Used to delete the stored data
-         */
-        deleteItem(key: string): Promise<DeleteResponse>;
-        
-        /**
-         * Stores `value` under `key` in the database for the app  (**without any reference to the instance**)
-         * @param {string} key - Used to delete the stored data
-         * @param {any} value - The value to store
-         * @param {object=} options
-         * @param {string=} options.previous_version - Use the new version of the storage (instance-less)
-         */
-        setItem(key: string, value: any, options?: { previous_version?: string }): Promise<SetResponse>;
-        /***
-         * The instance storage is a key-value database that is scoped to a specific app instance.
-         * **Does not work** for instance-less apps.
-         */
-        instance: {
-            /**
-             * Returns a stored value from the database under `key` for a specific app instance
-             * @param key
-             */
-            getItem(key: string): Promise<GetResponse>;
-            
-            /**
-             * Deletes a stored value from the database under `key` for a specific app instance
-             * @param key
-             */
-            deleteItem(key: string): Promise<DeleteResponse>;
-            
-            /**
-             * Stores `value` under `key` in the database for a specific app instance
-             * @param key
-             * @param value
-             * @param options
-             */
-            setItem(key: string, value: any, options?: { previous_version?: string }): Promise<SetResponse>;
-        };
+    setItem(key: string, value: any, options?: { previous_version?: string }): Promise<SetResponse>;
+    /***
+     * The instance storage is a key-value database that is scoped to a specific app instance.
+     * **Does not work** for instance-less apps.
+     */
+    instance: {
+      /**
+       * Returns a stored value from the database under `key` for a specific app instance
+       * @param key
+       */
+      getItem(key: string): Promise<GetResponse>;
+
+      /**
+       * Deletes a stored value from the database under `key` for a specific app instance
+       * @param key
+       */
+      deleteItem(key: string): Promise<DeleteResponse>;
+
+      /**
+       * Stores `value` under `key` in the database for a specific app instance
+       * @param key
+       * @param value
+       * @param options
+       */
+      setItem(key: string, value: any, options?: { previous_version?: string }): Promise<SetResponse>;
     };
+  };
 }