@inditextech/weave-store-websockets 0.1.1 → 0.2.0

package/dist/client.d.ts

@@ -1,56 +1,489 @@
-import { IncomingMessage } from 'http';
-import { WeaveAwarenessChange } from '@inditextech/weave-types';
-import { WeaveStore } from '@inditextech/weave-sdk';
-import { WeaveStoreOptions } from '@inditextech/weave-types';
-import { WebsocketProvider } from 'y-websocket';
-import * as Y from 'yjs';
-
-export declare type ExtractRoomId = (req: IncomingMessage) => string | undefined;
-
-export declare type FetchInitialState = (doc: Y.Doc) => void;
-
-export declare type FetchRoom = (roomId: string) => Promise<Uint8Array | null>;
-
-export declare type PerformUpgrade = (req: IncomingMessage) => Promise<boolean>;
-
-export declare type PersistRoom = (roomId: string, actualState: Uint8Array<ArrayBufferLike>) => Promise<void>;
-
-export declare const WEAVE_STORE_WEBSOCKETS = "store-websockets";
-
-export declare const WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS: {
-    readonly CONNECTING: "connecting";
-    readonly CONNECTED: "connected";
-    readonly DISCONNECTED: "disconnected";
-};
-
-export declare class WeaveStoreWebsockets extends WeaveStore {
-    private websocketOptions;
-    private roomId;
-    protected provider: WebsocketProvider;
-    protected name: string;
-    protected supportsUndoManager: boolean;
-    constructor(storeOptions: WeaveStoreOptions, websocketOptions: WeaveStoreWebsocketsOptions);
-    private init;
-    connect(): void;
-    disconnect(): void;
-    setAwarenessInfo(field: string, value: unknown): void;
-    onAwarenessChange<K extends string, T>(callback: (changes: WeaveAwarenessChange<K, T>[]) => void): void;
-}
-
-export declare type WeaveStoreWebsocketsCallbacks = {
-    onConnectionStatusChange?: (status: WeaveStoreWebsocketsConnectionStatus) => void;
-};
-
-export declare type WeaveStoreWebsocketsConnectionStatus = (typeof WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS)[WeaveStoreWebsocketsConnectionStatusKeys];
-
-export declare type WeaveStoreWebsocketsConnectionStatusKeys = keyof typeof WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS;
-
-export declare type WeaveStoreWebsocketsOptions = {
-    roomId: string;
-    wsOptions: {
-        serverUrl: string;
-    };
-    callbacks?: WeaveStoreWebsocketsCallbacks;
-};
-
-export { }
+import { ExtractRoomId, FetchInitialState, FetchRoom, PerformUpgrade, PersistRoom, WEAVE_STORE_WEBSOCKETS$1 as WEAVE_STORE_WEBSOCKETS, WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS$1 as WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS, WeaveStoreWebsocketsCallbacks, WeaveStoreWebsocketsConnectionStatus, WeaveStoreWebsocketsConnectionStatusKeys, WeaveStoreWebsocketsOptions } from "./types.d-BmaSRpK3.js";
+import { Doc } from "yjs";
+import { WebsocketProvider } from "y-websocket";
+import Konva from "konva";
+import { Vector2d } from "konva/lib/types";
+import { MappedTypeDescription } from "@syncedstore/core/types/doc";
+import Emittery from "emittery";
+import pino, { Logger } from "pino";
+import { StageConfig } from "konva/lib/Stage";
+
+//#region ../sdk/dist/sdk.d.ts
+//#region ../types/dist/types.d.ts
+declare const WEAVE_INSTANCE_STATUS: {
+  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$1 = {
+  getUser: () => WeaveUser$1;
+  undoManagerOptions?: WeaveUndoManagerOptions$1;
+};
+interface WeaveStoreBase {
+  connect(): void;
+  disconnect(): void;
+  onAwarenessChange<K extends string, T>(callback: (changes: WeaveAwarenessChange$1<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[];
+  callbacks?: WeaveCallbacks;
+  logger?: WeaveLoggerConfig;
+};
+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 WeaveMousePointInfoSimple = {
+  mousePoint: Vector2d;
+  container: Konva.Layer | Konva.Group | undefined;
+};
+type WeaveMousePointInfo = WeaveMousePointInfoSimple & {
+  measureContainer: Konva.Layer | Konva.Group | undefined;
+};
+type WeaveSerializedGroup = {
+  serializedNodes: WeaveStateElement[];
+  minPoint: Vector2d;
+} | undefined;
+type WeaveNodeFound = {
+  node: WeaveStateElement | null;
+  parent: WeaveStateElement | null;
+  index: number;
+};
+type WeaveAwarenessChange$1<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 = {
+  id: string;
+  name: string;
+};
+type WeaveUndoManagerOptions$1 = {
+  captureTimeout?: number;
+  trackedOrigins?: Set<any>;
+};
+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/base/node.d.ts
+interface WeaveNodeBase {
+  createNode(id: string, props: WeaveElementAttributes): WeaveStateElement;
+  createInstance(props: WeaveElementAttributes): WeaveElementInstance;
+  updateInstance(instance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  removeInstance(instance: WeaveElementInstance): void;
+  toNode(instance: WeaveElementInstance): WeaveStateElement;
+} //#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$1;
+  private state;
+  private latestState;
+  private document;
+  private logger;
+  private undoManager;
+  private isRoomLoaded;
+  constructor(config: WeaveStoreOptions$1);
+  getName(): string;
+  getLogger(): Logger;
+  register(instance: Weave): WeaveStore;
+  getUser(): WeaveUser$1;
+  setState(state: WeaveState): void;
+  setLatestState(newState: WeaveState): void;
+  getLatestState(): WeaveState;
+  getDocument(): Doc;
+  getState(): MappedTypeDescription<WeaveState>;
+  getStateJson(): WeaveState;
+  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$1<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[]) => 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): WeaveStateElement;
+  abstract createInstance(props: WeaveElementAttributes): WeaveElementInstance;
+  abstract updateInstance(instance: WeaveElementInstance, nextProps: WeaveElementAttributes): void;
+  abstract removeInstance(instance: WeaveElementInstance): void;
+  abstract toNode(instance: WeaveElementInstance): WeaveStateElement;
+}
+
+//#endregion
+//#region src/actions/types.d.ts
+type WeaveActionPropsChangeCallback = (props: WeaveElementAttributes) => void;
+type WeaveActionCallbacks = {
+  onPropsChange?: WeaveActionPropsChangeCallback;
+};
+
+//#endregion
+//#region src/actions/action.d.ts
+declare abstract class WeaveAction {
+  protected instance: Weave;
+  protected name: string;
+  props: WeaveElementAttributes;
+  protected callbacks: WeaveActionCallbacks | undefined;
+  private logger;
+  constructor(callbacks?: WeaveActionCallbacks);
+  getName(): string;
+  getLogger(): Logger;
+  register(instance: Weave): WeaveAction;
+  updateProps(props: WeaveElementAttributes): void;
+  getProps(): WeaveElementAttributes;
+  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): void;
+  getStatus(): WeaveStatus;
+  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;
+  updatePropsAction(actionName: string, params: WeaveElementAttributes): void;
+  cancelAction(actionName: string): void;
+  update(newState: WeaveState): void;
+  render(): void;
+  findNodeById(tree: WeaveStateElement, key: string, parent?: WeaveStateElement | null, index?: number): WeaveNodeFound;
+  findNodesByType(tree: WeaveStateElement, nodeType: string): WeaveStateElement[];
+  getNode(nodeKey: string): {
+    node: WeaveStateElement | null;
+    parent: WeaveStateElement | null;
+    index: number;
+  };
+  addNode(node: WeaveStateElement, parentId?: string, index?: number | undefined, doRender?: boolean): void;
+  updateNode(node: WeaveStateElement, doRender?: boolean): void;
+  removeNode(node: WeaveStateElement, doRender?: boolean): void;
+  removeNodes(nodes: WeaveStateElement[], doRender?: boolean): void;
+  moveNode(node: WeaveStateElement, position: WeavePosition, doRender?: boolean): void;
+  moveUp(node: WeaveElementInstance): void;
+  moveDown(node: WeaveElementInstance): void;
+  sendToBack(node: WeaveElementInstance): void;
+  bringToFront(node: WeaveElementInstance): void;
+  group(nodes: WeaveStateElement[]): void;
+  unGroup(group: WeaveStateElement): 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[];
+  exportStage(options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
+  exportNode(node: WeaveElementInstance, options: WeaveExportNodeOptions): Promise<HTMLImageElement>;
+} //#endregion
+//#region ../types/dist/types.d.ts
+
+//#endregion
+//#region src/utils.d.ts
+//#endregion
+//#region src/base/store.d.ts
+type WeaveStoreOptions = {
+  getUser: () => WeaveUser;
+  undoManagerOptions?: WeaveUndoManagerOptions;
+};
+type WeaveAwarenessChange<K extends string, T> = { [key in K]: T };
+type WeaveUser = {
+  name: string;
+  email: string;
+};
+type WeaveUndoManagerOptions = {
+  captureTimeout?: number;
+  trackedOrigins?: Set<any>;
+};
+
+//#endregion
+//#region src/store-websockets.d.ts
+declare class WeaveStoreWebsockets extends WeaveStore {
+  private websocketOptions;
+  private roomId;
+  protected provider: WebsocketProvider;
+  protected name: string;
+  protected supportsUndoManager: boolean;
+  constructor(storeOptions: WeaveStoreOptions, websocketOptions: WeaveStoreWebsocketsOptions);
+  private init;
+  connect(): void;
+  disconnect(): void;
+  setAwarenessInfo(field: string, value: unknown): void;
+  onAwarenessChange<K extends string, T>(callback: (changes: WeaveAwarenessChange<K, T>[]) => void): void;
+}
+
+//#endregion
+export { ExtractRoomId, FetchInitialState, FetchRoom, PerformUpgrade, PersistRoom, WEAVE_STORE_WEBSOCKETS, WEAVE_STORE_WEBSOCKETS_CONNECTION_STATUS, WeaveStoreWebsockets, WeaveStoreWebsocketsCallbacks, WeaveStoreWebsocketsConnectionStatus, WeaveStoreWebsocketsConnectionStatusKeys, WeaveStoreWebsocketsOptions };