Model Interfaces

/**
 * Main editor model interface
 */
interface IPublicModelEditor {
  /** Get editor property value */
  get(key: string): any;
  /** Set editor property value */
  set(key: string, value: any): void;
  /** Listen for property retrieval */
  onGot(key: string, fn: (value: any) => void): () => void;
  /** Listen for property changes */
  onChange(fn: (key: string, value: any, oldValue: any) => void): () => void;
  /** Register plugin */
  registerPlugin(plugin: IPublicTypePlugin, options?: any): void;
  /** Get current project */
  getProject(): IPublicModelProject;
  /** Get skeleton */
  getSkeleton(): IPublicModelSkeleton;
  /** Get material */
  getMaterial(): IPublicModelMaterial;
}

/**
 * Node model interface
 */
interface IPublicModelNode {
  /** Node unique identifier */
  id: string;
  /** Node title/label */
  title: string | IPublicTypeI18nData | ReactElement;
  /** Whether node is a container */
  isContainerNode: boolean;
  /** Whether node is root node */
  isRootNode: boolean;
  /** Node component metadata */
  componentMeta: IPublicModelComponentMeta;
  /** Node properties */
  props: IPublicModelProps;
  /** Node children */
  children: IPublicModelNodeChildren;
  /** Parent node */
  parent: IPublicModelNode | null;
  /** Document model reference */
  document: IPublicModelDocumentModel;
  /** Get node schema */
  getSchema(): IPublicTypeNodeSchema;
  /** Set node schema */
  setSchema(schema: IPublicTypeNodeSchema): void;
  /** Remove node */
  remove(): void;
  /** Select node */
  select(): void;
  /** Check if node can be removed */
  canRemove(): boolean;
  /** Check if node can have children */
  canAcceptChild(node: IPublicModelNode): boolean;
}

/**
 * Document model interface  
 */
interface IPublicModelDocumentModel {
  /** Document ID */
  id: string;
  /** Root node */
  root: IPublicModelNode;
  /** Selection model */
  selection: IPublicModelSelection;
  /** History model */
  history: IPublicModelHistory;
  /** Document schema */
  schema: IPublicTypeProjectSchema;
  /** Get node by ID */
  getNodeById(id: string): IPublicModelNode | null;
  /** Create node */
  createNode(schema: IPublicTypeNodeSchema): IPublicModelNode;
  /** Import schema */
  import(schema: IPublicTypeProjectSchema): void;
  /** Export schema */
  export(): IPublicTypeProjectSchema;
  /** Check if modified */
  isModified(): boolean;
  /** Save document */
  save(): Promise<void>;
}

/**
 * Component metadata model interface
 */
interface IPublicModelComponentMeta {
  /** Component name */
  componentName: string;
  /** Component title */
  title: string;
  /** Component icon */
  icon?: string;
  /** Component category */
  category?: string;
  /** Component tags */
  tags?: string[];
  /** NPM package info */
  npm: IPublicTypeNpmInfo;
  /** Property configurations */
  props: IPublicTypePropConfig[];
  /** Configure metadata */
  configure: IPublicTypeFieldConfig[];
  /** Available snippets */
  snippets: IPublicTypeSnippet[];
  /** Get property config */
  getPropConfig(propName: string): IPublicTypePropConfig | null;
  /** Check if advanced component */
  isAdvanced(): boolean;
  /** Check if container component */
  isContainer(): boolean;
}

/**
 * Node properties model interface
 */
interface IPublicModelProps {
  /** Get property value */
  get(key: string): any;
  /** Set property value */
  set(key: string, value: any): void;
  /** Delete property */
  delete(key: string): void;
  /** Check if property exists */
  has(key: string): boolean;
  /** Get all properties */
  getAll(): Record<string, any>;
  /** Set multiple properties */
  setAll(props: Record<string, any>): void;
  /** Get property keys */
  keys(): string[];
  /** Listen for property changes */
  onChange(fn: (key: string, value: any, oldValue: any) => void): () => void;
  /** Export as plain object */
  export(): Record<string, any>;
}

/**
 * Node children model interface
 */
interface IPublicModelNodeChildren {
  /** Children count */
  length: number;
  /** Get child at index */
  get(index: number): IPublicModelNode | null;
  /** Add child */
  add(node: IPublicModelNode, index?: number): void;
  /** Remove child */
  remove(node: IPublicModelNode): boolean;
  /** Remove child at index */
  removeAt(index: number): IPublicModelNode | null;
  /** Move child */
  move(from: number, to: number): void;
  /** Clear all children */
  clear(): void;
  /** Find child by ID */
  find(id: string): IPublicModelNode | null;
  /** Iterate over children */
  forEach(fn: (node: IPublicModelNode, index: number) => void): void;
  /** Map children to array */
  map<T>(fn: (node: IPublicModelNode, index: number) => T): T[];
  /** Filter children */
  filter(fn: (node: IPublicModelNode, index: number) => boolean): IPublicModelNode[];
}

/**
 * Selection model interface
 */
interface IPublicModelSelection {
  /** Currently selected nodes */
  selected: IPublicModelNode[];
  /** Select nodes */
  select(nodes: IPublicModelNode | IPublicModelNode[]): void;
  /** Clear selection */
  clear(): void;
  /** Check if node is selected */
  isSelected(node: IPublicModelNode): boolean;
  /** Get first selected node */
  getFirst(): IPublicModelNode | null;
  /** Get selection count */
  getCount(): number;
  /** Listen for selection changes */
  onChange(fn: (nodes: IPublicModelNode[]) => void): () => void;
}

/**
 * History model interface
 */
interface IPublicModelHistory {
  /** Check if can undo */
  canUndo(): boolean;
  /** Check if can redo */
  canRedo(): boolean;
  /** Perform undo */
  undo(): void;
  /** Perform redo */
  redo(): void;
  /** Clear history */
  clear(): void;
  /** Get history size */
  getSize(): number;
  /** Save state checkpoint */
  savePoint(): void;
  /** Listen for history changes */
  onChange(fn: () => void): () => void;
}

/**
 * Setting field model interface
 */
interface IPublicModelSettingField {
  /** Field key */
  key: string;
  /** Field title */
  title: string;
  /** Field type */
  type: string;
  /** Field value */
  value: any;
  /** Field setter */
  setter: IPublicTypeSetterConfig;
  /** Get field value */
  getValue(): any;
  /** Set field value */
  setValue(value: any): void;
  /** Reset field to default */
  reset(): void;
  /** Check if field is modified */
  isModified(): boolean;
  /** Listen for value changes */
  onChange(fn: (value: any, oldValue: any) => void): () => void;
}

/**
 * Drag object model interface
 */
interface IPublicModelDragObject {
  /** Drag object type */
  type: IPublicEnumDragObjectType;
  /** Drag object data */
  data: any;
  /** Check if valid drop target */
  canDropTo(target: IPublicModelNode): boolean;
  /** Get drop location */
  getDropLocation(target: IPublicModelNode, event: DragEvent): IPublicModelDropLocation;
}

/**
 * Drop location model interface
 */
interface IPublicModelDropLocation {
  /** Target node */
  target: IPublicModelNode;
  /** Drop index */
  index: number;
  /** Drop edge */
  edge: 'before' | 'after' | 'inside';
}

/**
 * Plugin context model interface
 */
interface IPublicModelPluginContext {
  /** Plugin name */
  name: string;
  /** Editor instance */
  editor: IPublicModelEditor;
  /** Plugin logger */
  logger: IPublicApiLogger;
  /** Plugin preferences */
  preference: IPublicModelPreference;
  /** Plugin event emitter */
  event: IPublicApiEvent;
  /** Plugin skeleton */
  skeleton: IPublicApiSkeleton;
  /** Plugin hotkey manager */
  hotkey: IPublicApiHotkey;
  /** Register command */
  registerCommand(command: IPublicTypeCommand): void;
  /** Unregister command */
  unregisterCommand(name: string): void;
}

/**
 * Preference model interface
 */
interface IPublicModelPreference {
  /** Get preference value */
  get(key: string): any;
  /** Set preference value */
  set(key: string, value: any): void;
  /** Check if preference exists */
  has(key: string): boolean;
  /** Delete preference */
  delete(key: string): void;
  /** Get all preferences */
  getAll(): Record<string, any>;
  /** Listen for preference changes */
  onChange(fn: (key: string, value: any, oldValue: any) => void): () => void;
}

/**
 * Window model interface
 */
interface IPublicModelWindow {
  /** Window ID */
  id: string;
  /** Window title */
  title: string;
  /** Window icon */
  icon?: string;
  /** Window active state */
  active: boolean;
  /** Window document */
  document: IPublicModelDocumentModel;
  /** Activate window */
  activate(): void;
  /** Close window */
  close(): void;
  /** Check if window is closable */
  isClosable(): boolean;
}

/**
 * Dragon model interface for drag and drop operations
 */
interface IPublicModelDragon {
  /** Whether currently dragging */
  readonly dragging: boolean;
  
  /** Listen for drag start events */
  onDragstart(func: (e: IPublicModelLocateEvent) => any): IPublicTypeDisposable;
  
  /** Listen for drag events */
  onDrag(func: (e: IPublicModelLocateEvent) => any): IPublicTypeDisposable;
  
  /** Listen for drag end events */
  onDragend(func: (o: { dragObject: IPublicModelDragObject; copy?: boolean }) => any): IPublicTypeDisposable;
  
  /** Set drag monitoring shell and boost function */
  from(shell: Element, boost: (e: MouseEvent) => IPublicTypeDragNodeDataObject | null): any;
  
  /** Boost drag object for dragging */
  boost(dragObject: IPublicTypeDragObject, boostEvent: MouseEvent | DragEvent, fromRglNode?: IPublicModelNode): void;
  
  /** Add sensor area */
  addSensor(sensor: any): void;
  
  /** Remove sensor area */
  removeSensor(sensor: any): void;
}

/**
 * Clipboard model interface
 */
interface IPublicModelClipboard {
  /** Set data to clipboard */
  setData(data: any): void;
  
  /** Wait for paste data with callback */
  waitPasteData(
    keyboardEvent: KeyboardEvent,
    cb: (data: any, clipboardEvent: ClipboardEvent) => void
  ): void;
}

/**
 * Active tracker model interface
 */
interface IPublicModelActiveTracker {
  /** Currently active node */
  activeNode: IPublicModelNode | null;
  
  /** Track active element */
  track(node: IPublicModelNode): void;
  
  /** Clear active tracking */
  clear(): void;
  
  /** Listen for active changes */
  onChange(fn: (node: IPublicModelNode | null) => void): () => void;
}

/**
 * Sensor model interface
 */
interface IPublicModelSensor {
  /** Sensor active state */
  active: boolean;
  
  /** Enter sensor area */
  enter(dragObject: IPublicModelDragObject): boolean;
  
  /** Leave sensor area */
  leave(dragObject: IPublicModelDragObject): void;
  
  /** Check if can drop */
  canDrop(dragObject: IPublicModelDragObject): boolean;
  
  /** Handle drop operation */
  drop(dragObject: IPublicModelDragObject, dropLocation: IPublicModelDropLocation): void;
}

/**
 * Detecting model interface
 */
interface IPublicModelDetecting {
  /** Currently detecting node */
  current: IPublicModelNode | null;
  
  /** Capture detecting for node */
  capture(node: IPublicModelNode): void;
  
  /** Release detecting */
  release(): void;
  
  /** Check if node is detecting */
  isDetecting(node: IPublicModelNode): boolean;
  
  /** Listen for detecting changes */
  onChange(fn: (node: IPublicModelNode | null) => void): () => void;
}

/**
 * Locate event model interface
 */
interface IPublicModelLocateEvent {
  /** Event type */
  type: string;
  
  /** Target element */
  target: Element;
  
  /** Client coordinates */
  clientX: number;
  clientY: number;
  
  /** Global coordinates */
  globalX: number;
  globalY: number;
  
  /** Original event */
  originalEvent: Event;
  
  /** Prevent default behavior */
  preventDefault(): void;
  
  /** Stop event propagation */
  stopPropagation(): void;
}