@inditextech/weave-react 0.1.1 → 0.2.1

package/dist/react.d.cts

@@ -0,0 +1,598 @@
+import React from "react";
+import Konva from "konva";
+import { Vector2d } from "konva/lib/types";
+import * as Y from "yjs";
+import { Doc } from "yjs";
+import Emittery from "emittery";
+import pino, { Logger } from "pino";
+import { StageConfig } from "konva/lib/Stage";
+import { StoreApi, UseBoundStore } from "zustand";
+
+//#region ../sdk/dist/sdk.d.ts
+//#region ../types/dist/types.d.ts
+declare const WEAVE_INSTANCE_STATUS$1: {
+  readonly "IDLE": "idle";
+  readonly "STARTING": "starting";
+  readonly "LOADING_FONTS": "loadingFonts";
+  readonly "RUNNING": "running";
+};
+declare const WEAVE_NODE_POSITION: {
+  readonly "UP": "up";
+  readonly "DOWN": "down";
+  readonly "FRONT": "front";
+  readonly "BACK": "back";
+};
+declare const WEAVE_EXPORT_FORMATS: {
+  readonly "PNG": "image/png";
+  readonly "JPEG": "image/jpeg";
+};
+//#endregion
+//#region src/base/action.d.ts
+interface WeaveActionBase {
+  init?(): void;
+  trigger(cancelAction: () => void, params?: unknown): unknown;
+  internalUpdate?(): void;
+  cleanup?(): void;
+}
+
+//#endregion
+//#region src/base/plugin.d.ts
+interface WeavePluginBase {
+  init?(): void;
+  render?(): void;
+  enable(): void;
+  disable(): void;
+  isEnabled(): boolean;
+}
+
+//#endregion
+//#region src/base/store.d.ts
+type WeaveStoreOptions = {
+  getUser: () => WeaveUser$1;
+  undoManagerOptions?: WeaveUndoManagerOptions;
+};
+interface WeaveStoreBase {
+  connect(): void;
+  disconnect(): void;
+  onAwarenessChange<K extends string, T>(callback: (changes: WeaveAwarenessChange<K, T>[]) => void): void;
+  setAwarenessInfo(field: string, value: unknown): void;
+}
+
+//#endregion
+//#region src/types.d.ts
+type WeaveConfig = {
+  store: WeaveStoreBase;
+  nodes?: WeaveNodeBase[];
+  actions?: WeaveActionBase[];
+  plugins?: WeavePluginBase[];
+  fonts?: WeaveFont$1[];
+  callbacks?: WeaveCallbacks$1;
+  logger?: WeaveLoggerConfig;
+};
+type WeaveStatusKeys$1 = keyof typeof WEAVE_INSTANCE_STATUS$1;
+type WeaveStatus$1 = (typeof WEAVE_INSTANCE_STATUS$1)[WeaveStatusKeys$1];
+type WeaveElementAttributes$1 = {
+  [key: string]: any;
+  id?: string;
+  nodeType?: string;
+  children?: WeaveStateElement$1[];
+};
+type WeaveStateElement$1 = {
+  key: string;
+  type: string;
+  props: WeaveElementAttributes$1;
+};
+type WeaveState$1 = {
+  weave: {
+    key: "stage";
+    type: "stage";
+    props: {
+      [key: string]: unknown;
+      id: "stage";
+      children: WeaveStateElement$1[];
+    };
+  } | Record<string, WeaveStateElement$1>;
+};
+type WeaveSelection$1 = {
+  instance: Konva.Shape | Konva.Group;
+  node: WeaveStateElement$1;
+};
+type WeaveMousePointInfoSimple = {
+  mousePoint: Vector2d;
+  container: Konva.Layer | Konva.Group | undefined;
+};
+type WeaveMousePointInfo = WeaveMousePointInfoSimple & {
+  measureContainer: Konva.Layer | Konva.Group | undefined;
+};
+type WeaveSerializedGroup = {
+  serializedNodes: WeaveStateElement$1[];
+  minPoint: Vector2d;
+} | undefined;
+type WeaveNodeFound = {
+  node: WeaveStateElement$1 | null;
+  parent: WeaveStateElement$1 | null;
+  index: number;
+};
+type WeaveAwarenessChange<K extends string, T> = { [key in K]: T };
+type WeaveElementInstance = Konva.Layer | Konva.Group | Konva.Shape;
+type WeaveLoggerConfig = {
+  disabled?: boolean;
+  level?: "debug" | "info" | "warn" | "error";
+};
+type WeavePositionKeys = keyof typeof WEAVE_NODE_POSITION;
+type WeavePosition = (typeof WEAVE_NODE_POSITION)[WeavePositionKeys];
+type WeaveExportNodeOptions = {
+  format?: typeof WEAVE_EXPORT_FORMATS.PNG;
+  padding?: number;
+  pixelRatio?: number;
+  backgroundColor?: string;
+  quality?: number;
+};
+type WeaveUser$1 = {
+  name: string;
+  email: string;
+};
+type WeaveFont$1 = {
+  id: string;
+  name: string;
+};
+type WeaveUndoManagerOptions = {
+  captureTimeout?: number;
+  trackedOrigins?: Set<any>;
+};
+type WeaveUndoRedoChange$1 = {
+  canRedo: boolean;
+  canUndo: boolean;
+  redoStackLength: number;
+  undoStackLength: number;
+};
+type WeaveCallbacks$1 = {
+  onRender?: () => void;
+  onRoomLoaded?: (loaded: boolean) => void;
+  onInstanceStatus?: (status: WeaveStatus$1) => void;
+  onActiveActionChange?: (actionName: string | undefined) => void;
+  onStateChange?: (state: WeaveState$1) => void;
+  onUndoManagerStatusChange?: (undoManagerStatus: WeaveUndoRedoChange$1) => void;
+};
+declare type docElementTypeDescription = "xml" | "text" | Array<any> | object;
+declare type DocTypeDescription = {
+  [key: string]: docElementTypeDescription;
+};
+declare type MappedTypeDescription<T extends DocTypeDescription> = { readonly [P in keyof T]: T[P] extends "xml" ? Y.XmlFragment : T[P] extends "text" ? Y.Text : T[P] extends Array<any> ? T[P] : T[P] extends object ? Partial<T[P]> : never };
+//#endregion
+//#region src/base/node.d.ts
+interface WeaveNodeBase {
+  createNode(id: string, props: WeaveElementAttributes$1): WeaveStateElement$1;
+  createInstance(props: WeaveElementAttributes$1): WeaveElementInstance;
+  updateInstance(instance: WeaveElementInstance, nextProps: WeaveElementAttributes$1): void;
+  removeInstance(instance: WeaveElementInstance): void;
+  toNode(instance: WeaveElementInstance): WeaveStateElement$1;
+} //#endregion
+//#region src/stores/store.d.ts
+
+//#endregion
+declare abstract class WeaveStore implements WeaveStoreBase {
+  protected instance: Weave;
+  protected name: string;
+  protected supportsUndoManager: boolean;
+  protected config: WeaveStoreOptions;
+  private state;
+  private latestState;
+  private document;
+  private logger;
+  private undoManager;
+  private isRoomLoaded;
+  constructor(config: WeaveStoreOptions);
+  getName(): string;
+  getLogger(): Logger;
+  register(instance: Weave): WeaveStore;
+  getUser(): WeaveUser$1;
+  setState(state: WeaveState$1): void;
+  setLatestState(newState: WeaveState$1): void;
+  getLatestState(): WeaveState$1;
+  getDocument(): Doc;
+  getState(): MappedTypeDescription<WeaveState$1>;
+  getStateJson(): WeaveState$1;
+  setup(): void;
+  canUndoStateStep(): boolean;
+  canRedoStateStep(): boolean;
+  undoStateStep(): void;
+  redoStateStep(): void;
+  abstract connect(): void;
+  abstract disconnect(): void;
+  abstract onAwarenessChange<K extends string, T>(callback: (changes: WeaveAwarenessChange<K, T>[]) => void): void;
+  abstract setAwarenessInfo(field: string, value: unknown): void;
+}
+
+//#endregion
+//#region src/plugins/plugin.d.ts
+declare abstract class WeavePlugin implements WeavePluginBase {
+  protected instance: Weave;
+  protected name: string;
+  protected enabled: boolean;
+  private logger;
+  register(instance: Weave): WeavePlugin;
+  getName(): string;
+  getLogger(): Logger;
+  isEnabled(): boolean;
+  abstract init?(): void;
+  abstract render?(): void;
+  abstract enable(): void;
+  abstract disable(): void;
+}
+
+//#endregion
+//#region src/plugins/nodes-selection/types.d.ts
+type WeaveNodesSelectionChangeCallback = (nodes: WeaveSelection$1[]) => void;
+type WeaveNodesSelectionStageSelectionCallback = () => void;
+type WeaveNodesSelectionPluginCallbacks = {
+  onNodesChange: WeaveNodesSelectionChangeCallback;
+  onStageSelection?: WeaveNodesSelectionStageSelectionCallback;
+};
+
+//#endregion
+//#region src/plugins/nodes-selection/nodes-selection.d.ts
+declare class WeaveNodesSelectionPlugin extends WeavePlugin {
+  private tr;
+  private selectionRectangle;
+  private active;
+  private cameFromSelectingMultiple;
+  private selecting;
+  private initialized;
+  private callbacks;
+  render: undefined;
+  constructor(callbacks: WeaveNodesSelectionPluginCallbacks);
+  getName(): string;
+  getLayerName(): string;
+  initLayer(): void;
+  init(): void;
+  private getLayer;
+  private triggerSelectedNodesEvent;
+  private initEvents;
+  getTransformer(): Konva.Transformer;
+  setSelectedNodes(nodes: Konva.Node[]): void;
+  getSelectedNodes(): (Konva.Group | Konva.Shape)[];
+  removeSelectedNodes(): void;
+  selectAll(): void;
+  selectNone(): void;
+  enable(): void;
+  disable(): void;
+}
+
+//#endregion
+//#region src/nodes/node.d.ts
+declare abstract class WeaveNode implements WeaveNodeBase {
+  protected instance: Weave;
+  protected nodeType: string;
+  private logger;
+  protected previousPointer: string | null;
+  register(instance: Weave): WeaveNode;
+  getNodeType(): string;
+  getLogger(): Logger;
+  getSelectionPlugin(): WeaveNodesSelectionPlugin;
+  isSelecting(): boolean;
+  isPasting(): boolean;
+  isNodeSelected(ele: Konva.Node): boolean;
+  setupDefaultNodeEvents(node: Konva.Node): void;
+  abstract createNode(id: string, props: WeaveElementAttributes$1): WeaveStateElement$1;
+  abstract createInstance(props: WeaveElementAttributes$1): WeaveElementInstance;
+  abstract updateInstance(instance: WeaveElementInstance, nextProps: WeaveElementAttributes$1): void;
+  abstract removeInstance(instance: WeaveElementInstance): void;
+  abstract toNode(instance: WeaveElementInstance): WeaveStateElement$1;
+}
+
+//#endregion
+//#region src/actions/types.d.ts
+type WeaveActionPropsChangeCallback = (props: WeaveElementAttributes$1) => void;
+type WeaveActionCallbacks = {
+  onPropsChange?: WeaveActionPropsChangeCallback;
+};
+
+//#endregion
+//#region src/actions/action.d.ts
+declare abstract class WeaveAction {
+  protected instance: Weave;
+  protected name: string;
+  props: WeaveElementAttributes$1;
+  protected callbacks: WeaveActionCallbacks | undefined;
+  private logger;
+  constructor(callbacks?: WeaveActionCallbacks);
+  getName(): string;
+  getLogger(): Logger;
+  register(instance: Weave): WeaveAction;
+  updateProps(props: WeaveElementAttributes$1): void;
+  getProps(): WeaveElementAttributes$1;
+  abstract init?(): void;
+  abstract trigger(cancelAction: () => void, params?: unknown): unknown;
+  abstract internalUpdate?(): void;
+  abstract cleanup?(): void;
+}
+
+//#endregion
+//#region src/logger/logger.d.ts
+declare class WeaveLogger {
+  private config;
+  private disabled;
+  private logger;
+  constructor(config: WeaveLoggerConfig);
+  private log;
+  getDisabled(): boolean;
+  getLevel(): pino.LevelWithSilentOrString;
+  getLogger(): Logger;
+  getChildLogger(name: string): pino.Logger<never, boolean>;
+}
+
+//#endregion
+//#region src/managers/register.d.ts
+declare class WeaveRegisterManager {
+  private instance;
+  private nodesHandlers;
+  private actionsHandlers;
+  private plugins;
+  private logger;
+  constructor(instance: Weave);
+  getPlugins(): Record<string, WeavePlugin>;
+  getNodesHandlers(): Record<string, WeaveNode>;
+  getActionsHandlers(): Record<string, WeaveAction>;
+  getPlugin<T extends WeavePlugin>(pluginName: string): T;
+  getActionHandler<T extends WeaveAction>(actionName: string): T;
+  getNodeHandler(nodeType: string): WeaveNode;
+  registerPlugins(): void;
+  registerPlugin(plugin: WeavePlugin): void;
+  registerNodesHandlers(): void;
+  registerNodeHandler(node: WeaveNode): void;
+  registerActionsHandlers(): void;
+  registerActionHandler(action: WeaveAction): void;
+}
+
+//#endregion
+//#region src/managers/stage.d.ts
+declare class WeaveStageManager {
+  private instance;
+  private logger;
+  private stage;
+  private config;
+  constructor(instance: Weave, config: Konva.StageConfig);
+  getConfiguration(): StageConfig;
+  setStage(stage: Konva.Stage): void;
+  getStage(): Konva.Stage;
+  getMainLayer(): Konva.Layer | undefined;
+  getInstanceRecursive(instance: Konva.Node, filterInstanceType?: string[]): Konva.Node;
+  initStage(): void;
+}
+
+//#endregion
+//#region src/weave.d.ts
+declare class Weave extends Emittery {
+  private id;
+  private config;
+  private logger;
+  private moduleLogger;
+  private reconciler;
+  private stateSerializer;
+  private renderer;
+  private status;
+  private setupManager;
+  private registerManager;
+  private stateManager;
+  private storeManager;
+  private stageManager;
+  private groupsManager;
+  private targetingManager;
+  private cloningManager;
+  private fontsManager;
+  private zIndexManager;
+  private pluginsManager;
+  private actionsManager;
+  private exportManager;
+  constructor(weaveConfig: WeaveConfig, stageConfig: Konva.StageConfig);
+  setupRenderer(): void;
+  setStatus(status: WeaveStatus$1): void;
+  getStatus(): WeaveStatus$1;
+  setStore(store: WeaveStore): void;
+  start(): Promise<void>;
+  getId(): string;
+  getConfiguration(): WeaveConfig;
+  emitEvent<T>(event: string, payload: T): void;
+  addEventListener<T>(event: string, callback: (payload: T) => void): void;
+  removeEventListener<T>(event: string, callback: (payload: T) => void): void;
+  getLogger(): WeaveLogger;
+  getMainLogger(): Logger;
+  getChildLogger(name: string): pino.Logger<never, boolean>;
+  getStageManager(): WeaveStageManager;
+  getStage(): Konva.Stage;
+  getMainLayer(): Konva.Layer | undefined;
+  setStage(stage: Konva.Stage): void;
+  getStageConfiguration(): StageConfig;
+  getInstanceRecursive(instance: Konva.Node, filterInstanceType?: string[]): Konva.Node;
+  getRegisterManager(): WeaveRegisterManager;
+  getPlugins(): Record<string, WeavePlugin>;
+  getPlugin<T extends WeavePlugin>(pluginName: string): T;
+  getNodesHandlers(): Record<string, WeaveNode>;
+  getNodeHandler<T extends WeaveNode>(nodeType: string): T;
+  getActionsHandlers(): Record<string, WeaveAction>;
+  getActionHandler<T extends WeaveAction>(actionName: string): T;
+  getStore<T extends WeaveStore>(): T;
+  registerPlugin(plugin: WeavePlugin): void;
+  registerNodeHandler(node: WeaveNode): void;
+  registerActionHandler(action: WeaveAction): void;
+  registerStore(store: WeaveStore): void;
+  isPluginEnabled(pluginName: string): boolean;
+  enablePlugin(pluginName: string): void;
+  disablePlugin(pluginName: string): void;
+  getActiveAction(): string | undefined;
+  triggerAction<T>(actionName: string, params?: T): unknown;
+  getPropsAction(actionName: string): WeaveElementAttributes$1;
+  updatePropsAction(actionName: string, params: WeaveElementAttributes$1): void;
+  cancelAction(actionName: string): void;
+  update(newState: WeaveState$1): void;
+  render(): void;
+  findNodeById(tree: WeaveStateElement$1, key: string, parent?: WeaveStateElement$1 | null, index?: number): WeaveNodeFound;
+  findNodesByType(tree: WeaveStateElement$1, nodeType: string): WeaveStateElement$1[];
+  getNode(nodeKey: string): {
+    node: WeaveStateElement$1 | null;
+    parent: WeaveStateElement$1 | null;
+    index: number;
+  };
+  addNode(node: WeaveStateElement$1, parentId?: string, index?: number | undefined, doRender?: boolean): void;
+  updateNode(node: WeaveStateElement$1, doRender?: boolean): void;
+  removeNode(node: WeaveStateElement$1, doRender?: boolean): void;
+  removeNodes(nodes: WeaveStateElement$1[], doRender?: boolean): void;
+  moveNode(node: WeaveStateElement$1, position: WeavePosition, doRender?: boolean): void;
+  moveUp(node: WeaveElementInstance): void;
+  moveDown(node: WeaveElementInstance): void;
+  sendToBack(node: WeaveElementInstance): void;
+  bringToFront(node: WeaveElementInstance): void;
+  group(nodes: WeaveStateElement$1[]): void;
+  unGroup(group: WeaveStateElement$1): void;
+  getMousePointer(point?: Vector2d): WeaveMousePointInfo;
+  getMousePointerRelativeToContainer(container: Konva.Group | Konva.Layer): WeaveMousePointInfoSimple;
+  nodesToGroupSerialized(instancesToClone: Konva.Node[]): WeaveSerializedGroup;
+  cloneNodes(instancesToClone: Konva.Node[], targetContainer: Konva.Layer | Konva.Group | undefined, onPoint: Vector2d): void;
+  getFonts(): WeaveFont$1[];
+  exportStage(options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
+  exportNode(node: WeaveElementInstance, options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
+}
+
+//#endregion
+//#region src/utils.d.ts
+
+type WeaveConnectedUsersChanged = {
+  [userName: string]: WeaveUser$1;
+}; //#endregion
+//#region ../types/dist/types.d.ts
+declare const WEAVE_INSTANCE_STATUS: {
+  readonly "IDLE": "idle";
+  readonly "STARTING": "starting";
+  readonly "LOADING_FONTS": "loadingFonts";
+  readonly "RUNNING": "running";
+};
+type WeaveStatusKeys = keyof typeof WEAVE_INSTANCE_STATUS;
+type WeaveStatus = (typeof WEAVE_INSTANCE_STATUS)[WeaveStatusKeys];
+type WeaveElementAttributes = {
+  [key: string]: any;
+  id?: string;
+  nodeType?: string;
+  children?: WeaveStateElement[];
+};
+type WeaveStateElement = {
+  key: string;
+  type: string;
+  props: WeaveElementAttributes;
+};
+type WeaveState = {
+  weave: {
+    key: "stage";
+    type: "stage";
+    props: {
+      [key: string]: unknown;
+      id: "stage";
+      children: WeaveStateElement[];
+    };
+  } | Record<string, WeaveStateElement>;
+};
+type WeaveSelection = {
+  instance: Konva.Shape | Konva.Group;
+  node: WeaveStateElement;
+};
+type WeaveUser = {
+  name: string;
+  email: string;
+};
+type WeaveFont = {
+  id: string;
+  name: string;
+};
+type WeaveUndoRedoChange = {
+  canRedo: boolean;
+  canUndo: boolean;
+  redoStackLength: number;
+  undoStackLength: number;
+};
+type WeaveCallbacks = {
+  onRender?: () => void;
+  onRoomLoaded?: (loaded: boolean) => void;
+  onInstanceStatus?: (status: WeaveStatus) => void;
+  onActiveActionChange?: (actionName: string | undefined) => void;
+  onStateChange?: (state: WeaveState) => void;
+  onUndoManagerStatusChange?: (undoManagerStatus: WeaveUndoRedoChange) => void;
+};
+
+//#endregion
+//#region src/components/provider.d.ts
+type WeaveProviderType = {
+  containerId: string;
+  getUser: () => WeaveUser;
+  fonts?: WeaveFont[];
+  store: WeaveStore;
+  nodes?: WeaveNode[];
+  actions?: WeaveAction[];
+  plugins?: WeavePlugin[];
+  customNodes?: WeaveNode[];
+  customActions?: WeaveAction[];
+  customPlugins?: WeavePlugin[];
+  callbacks?: WeaveCallbacks;
+  children: React.ReactNode;
+};
+declare const WeaveProvider: ({
+  containerId,
+  getUser,
+  store,
+  nodes,
+  actions,
+  plugins,
+  customPlugins,
+  fonts,
+  callbacks,
+  children
+}: Readonly<WeaveProviderType>) => React.JSX.Element;
+
+//#endregion
+//#region src/components/store.d.ts
+interface WeaveRuntimeState {
+  instance: Weave | null;
+  appState: WeaveState;
+  status: WeaveStatus;
+  connection: {
+    status: string;
+  };
+  room: {
+    loaded: boolean;
+  };
+  users: WeaveConnectedUsersChanged;
+  undoRedo: {
+    canUndo: boolean;
+    canRedo: boolean;
+  };
+  zoom: {
+    value: number;
+    canZoomIn: boolean;
+    canZoomOut: boolean;
+  };
+  selection: {
+    nodes: WeaveSelection[];
+    node: WeaveStateElement | undefined;
+  };
+  actions: {
+    active: boolean;
+    actual: string | undefined;
+  };
+  setInstance: (newInstance: Weave | null) => void;
+  setStatus: (newStatus: WeaveStatus) => void;
+  setAppState: (newAppState: WeaveState) => void;
+  setConnectionStatus: (newConnectionStatus: string) => void;
+  setRoomLoaded: (newStatus: boolean) => void;
+  setUsers: (newUsers: WeaveConnectedUsersChanged) => void;
+  setCanUndo: (newCanUndo: boolean) => void;
+  setCanRedo: (newCanRedo: boolean) => void;
+  setZoom: (newZoom: number) => void;
+  setCanZoomIn: (newCanZoomIn: boolean) => void;
+  setCanZoomOut: (newCanZoomOut: boolean) => void;
+  setSelectedNodes: (newSelectedNodes: WeaveSelection[]) => void;
+  setNode: (newNode: WeaveStateElement | undefined) => void;
+  setActualAction: (newActualAction: string | undefined) => void;
+}
+declare const useWeave: UseBoundStore<StoreApi<WeaveRuntimeState>>;
+
+//#endregion
+export { WeaveProvider, useWeave };