@rsconcept/domain 1.0.0

package/src/library/oss-layout-api.ts

@@ -0,0 +1,377 @@
+import { NodeType, type OperationSchema, OperationType } from './oss';
+import { type NodePosition, type OssLayout, type Position2D, type Rectangle2D } from './oss-layout';
+
+export const GRID_SIZE = 10; // pixels - size of OSS grid
+const MIN_DISTANCE = 2 * GRID_SIZE; // pixels - minimum distance between nodes
+
+export const OPERATION_NODE_WIDTH = 150;
+export const OPERATION_NODE_HEIGHT = 40;
+
+/** Layout manipulations for {@link OperationSchema}. */
+export class LayoutManager {
+  public oss: OperationSchema;
+  public layout: OssLayout;
+
+  constructor(oss: OperationSchema, layout?: OssLayout) {
+    this.oss = oss;
+    if (layout) {
+      this.layout = layout;
+    } else {
+      this.layout = this.oss.layout;
+    }
+  }
+
+  /** Calculate insert position for a new {@link Operation} */
+  newOperationPosition(position: Rectangle2D, parent: number | null, args: number[] = []): Rectangle2D {
+    const result = { ...position };
+    const parentNode = this.layout.find(pos => pos.nodeID === `b${parent}`) ?? null;
+    const operations = this.layout.filter(pos => pos.nodeID.startsWith('o'));
+    const hasArguments = args.length !== 0;
+    if (hasArguments) {
+      const pos = calculatePositionFromArgs(operations.filter(node => args.includes(Number(node.nodeID.slice(1)))));
+      result.x = pos.x;
+      result.y = pos.y;
+    } else if (parentNode) {
+      result.x = parentNode.x + MIN_DISTANCE;
+      result.y = parentNode.y + MIN_DISTANCE;
+    } else {
+      const pos = this.calculatePositionForFreeOperation(result);
+      result.x = pos.x;
+      result.y = pos.y;
+    }
+
+    const siblingBlocks = this.oss.blocks.filter(block => block.parent === parent).map(block => block.nodeID);
+    preventOverlap(
+      result,
+      this.layout.filter(node => siblingBlocks.includes(node.nodeID)),
+      {
+        moveX: !hasArguments,
+        moveY: hasArguments
+      }
+    );
+
+    preventOverlap(result, operations);
+    this.extendParentBounds(parentNode, result);
+
+    return result;
+  }
+
+  /** Calculate insert position for a new {@link Block} */
+  newBlockPosition(position: Rectangle2D, parent: number | null, blocks: number[], operations: number[]): Rectangle2D {
+    const blockNodes = blocks.map(id => this.layout.find(block => block.nodeID === `b${id}`)).filter(node => !!node);
+    const operationNodes = operations
+      .map(id => this.layout.find(operation => operation.nodeID === `o${id}`))
+      .filter(node => !!node);
+    const parentNode = this.layout.find(pos => pos.nodeID === `b${parent}`) ?? null;
+    const parentID = parentNode ? parent : null;
+
+    let result: Rectangle2D = { ...position };
+
+    if (blockNodes.length !== 0 || operationNodes.length !== 0) {
+      result = calculatePositionFromChildren(position, operationNodes, blockNodes);
+    } else if (parentNode) {
+      result = {
+        x: parentNode.x + MIN_DISTANCE,
+        y: parentNode.y + MIN_DISTANCE,
+        width: position.width,
+        height: position.height
+      };
+    } else {
+      result = this.calculatePositionForFreeBlock(result);
+    }
+
+    if (blockNodes.length === 0 && operationNodes.length === 0) {
+      const siblings = this.oss.blocks.filter(block => block.parent === parentID).map(block => block.nodeID);
+      preventOverlap(
+        result,
+        this.layout.filter(node => siblings.includes(node.nodeID))
+      );
+    }
+
+    this.extendParentBounds(parentNode, result);
+    return result;
+  }
+
+  /** Calculate insert position for a new clone of {@link Operation} */
+  newClonePosition(targetID: string): Rectangle2D | null {
+    const targetNode = this.layout.find(pos => pos.nodeID === targetID);
+    if (!targetNode) {
+      return null;
+    } else {
+      return {
+        x: targetNode.x + targetNode.width / 2 + GRID_SIZE,
+        y: targetNode.y + targetNode.height / 2 + GRID_SIZE,
+        width: OPERATION_NODE_WIDTH,
+        height: OPERATION_NODE_HEIGHT
+      };
+    }
+  }
+
+  /** Update layout when parent changes */
+  onChangeParent(targetID: string, newParent: string | null) {
+    const targetNode = this.layout.find(pos => pos.nodeID === targetID);
+    if (!targetNode) {
+      return;
+    }
+
+    const parentNode = this.layout.find(pos => pos.nodeID === newParent) ?? null;
+    const offset = this.calculateOffsetForParentChange(targetNode, parentNode);
+    if (offset.x === 0 && offset.y === 0) {
+      return;
+    }
+
+    targetNode.x += offset.x;
+    targetNode.y += offset.y;
+
+    const children = this.oss.hierarchy.expandAllOutputs([targetID]);
+    const childrenPositions = this.layout.filter(pos => children.includes(pos.nodeID));
+    for (const child of childrenPositions) {
+      child.x += offset.x;
+      child.y += offset.y;
+    }
+
+    this.extendParentBounds(parentNode, targetNode);
+  }
+
+  /** Calculate closest node to the left */
+  selectLeft(targetID: string): string | null {
+    const targetNode = this.layout.find(pos => pos.nodeID === targetID);
+    if (!targetNode) {
+      return null;
+    }
+    const operationNodes = this.layout.filter(pos => pos.nodeID !== targetID && pos.nodeID.startsWith('o'));
+    const leftNodes = operationNodes.filter(pos => pos.x <= targetNode.x);
+    if (leftNodes.length === 0) {
+      return null;
+    }
+    const similarYNodes = leftNodes.filter(pos => Math.abs(pos.y - targetNode.y) <= MIN_DISTANCE);
+    let closestNode: typeof targetNode | null = null;
+    if (similarYNodes.length > 0) {
+      closestNode = similarYNodes.reduce((prev, curr) => (curr.x > prev.x ? curr : prev));
+    } else {
+      closestNode = findClosestNodeByDistance(leftNodes, targetNode);
+    }
+    return closestNode?.nodeID ?? null;
+  }
+
+  /** Calculate closest node to the right */
+  selectRight(targetID: string): string | null {
+    const targetNode = this.layout.find(pos => pos.nodeID === targetID);
+    if (!targetNode) {
+      return null;
+    }
+    const operationNodes = this.layout.filter(pos => pos.nodeID !== targetID && pos.nodeID.startsWith('o'));
+    const rightNodes = operationNodes.filter(pos => pos.x >= targetNode.x);
+    if (rightNodes.length === 0) {
+      return null;
+    }
+    const similarYNodes = rightNodes.filter(pos => Math.abs(pos.y - targetNode.y) <= MIN_DISTANCE);
+    let closestNode: typeof targetNode | null = null;
+    if (similarYNodes.length > 0) {
+      closestNode = similarYNodes.reduce((prev, curr) => (curr.x < prev.x ? curr : prev));
+    } else {
+      closestNode = findClosestNodeByDistance(rightNodes, targetNode);
+    }
+    return closestNode?.nodeID ?? null;
+  }
+
+  /** Calculate closest node upwards */
+  selectUp(targetID: string): string | null {
+    const targetNode = this.layout.find(pos => pos.nodeID === targetID);
+    if (!targetNode) {
+      return null;
+    }
+
+    const operationNodes = this.layout.filter(pos => pos.nodeID !== targetID && pos.nodeID.startsWith('o'));
+    const upperNodes = operationNodes.filter(pos => pos.y <= targetNode.y - MIN_DISTANCE);
+    const targetOperation = this.oss.itemByNodeID.get(targetID);
+    if (upperNodes.length === 0 || !targetOperation || targetOperation.nodeType === NodeType.BLOCK) {
+      return null;
+    }
+
+    const predecessors = this.oss.graph.expandAllInputs([targetOperation.id]);
+    const predecessorNodes = upperNodes.filter(pos => predecessors.includes(Number(pos.nodeID.slice(1))));
+
+    let closestNode: typeof targetNode | null = null;
+    if (predecessorNodes.length > 0) {
+      closestNode = findClosestNodeByDistance(predecessorNodes, targetNode);
+    } else {
+      closestNode = findClosestNodeByDistance(upperNodes, targetNode);
+    }
+    return closestNode?.nodeID ?? null;
+  }
+
+  /** Calculate closest node downwards */
+  selectDown(targetID: string): string | null {
+    const targetNode = this.layout.find(pos => pos.nodeID === targetID);
+    if (!targetNode) {
+      return null;
+    }
+
+    const operationNodes = this.layout.filter(pos => pos.nodeID !== targetID && pos.nodeID.startsWith('o'));
+    const lowerNodes = operationNodes.filter(pos => pos.y >= targetNode.y - MIN_DISTANCE);
+    const targetOperation = this.oss.itemByNodeID.get(targetID);
+    if (lowerNodes.length === 0 || !targetOperation || targetOperation.nodeType === NodeType.BLOCK) {
+      return null;
+    }
+
+    const descendants = this.oss.graph.expandAllOutputs([targetOperation.id]);
+    const descendantsNodes = lowerNodes.filter(pos => descendants.includes(Number(pos.nodeID.slice(1))));
+
+    let closestNode: typeof targetNode | null = null;
+    if (descendantsNodes.length > 0) {
+      closestNode = findClosestNodeByDistance(descendantsNodes, targetNode);
+    } else {
+      closestNode = findClosestNodeByDistance(lowerNodes, targetNode);
+    }
+    return closestNode?.nodeID ?? null;
+  }
+
+  private extendParentBounds(parent: NodePosition | null, child: Rectangle2D) {
+    if (!parent) {
+      return;
+    }
+    const borderX = child.x + child.width + MIN_DISTANCE;
+    const borderY = child.y + child.height + MIN_DISTANCE;
+    parent.width = Math.max(parent.width, borderX - parent.x);
+    parent.height = Math.max(parent.height, borderY - parent.y);
+  }
+
+  private calculatePositionForFreeOperation(initial: Position2D): Position2D {
+    if (this.oss.operations.length === 0) {
+      return initial;
+    }
+
+    const freeInputs = this.oss.operations
+      .filter(
+        operation =>
+          operation.parent === null &&
+          (operation.operation_type !== OperationType.SYNTHESIS || operation.arguments.length === 0)
+      )
+      .map(operation => operation.nodeID);
+    let inputsPositions = this.layout.filter(pos => freeInputs.includes(pos.nodeID));
+    if (inputsPositions.length === 0) {
+      inputsPositions = this.layout.filter(pos => pos.nodeID.startsWith('o'));
+    }
+    const maxX = Math.max(...inputsPositions.map(node => node.x));
+    const minY = Math.min(...inputsPositions.map(node => node.y));
+    return {
+      x: maxX + OPERATION_NODE_WIDTH + MIN_DISTANCE + GRID_SIZE,
+      y: minY
+    };
+  }
+
+  private calculatePositionForFreeBlock(initial: Rectangle2D): Rectangle2D {
+    const rootBlocks = this.oss.blocks.filter(block => block.parent === null).map(block => block.nodeID);
+    const blocksPositions = this.layout.filter(pos => rootBlocks.includes(pos.nodeID));
+    if (blocksPositions.length === 0) {
+      return initial;
+    }
+    const maxX = Math.max(...blocksPositions.map(node => node.x + node.width));
+    const minY = Math.min(...blocksPositions.map(node => node.y));
+    return { ...initial, x: maxX + MIN_DISTANCE, y: minY };
+  }
+
+  private calculateOffsetForParentChange(target: NodePosition, parent: NodePosition | null): Position2D {
+    const newPosition = { ...target };
+    if (parent === null) {
+      const rootElements = this.oss.hierarchy.rootNodes();
+      const positions = this.layout.filter(pos => rootElements.includes(pos.nodeID));
+      preventOverlap(newPosition, positions);
+    } else if (!rectanglesStrictOverlap(target, parent)) {
+      newPosition.x = parent.x + MIN_DISTANCE;
+      newPosition.y = parent.y + MIN_DISTANCE;
+
+      const siblings = this.oss.hierarchy.at(parent.nodeID)?.outputs ?? [];
+      const siblingsPositions = this.layout.filter(pos => siblings.includes(pos.nodeID));
+      preventOverlap(newPosition, siblingsPositions);
+    }
+    return { x: newPosition.x - target.x, y: newPosition.y - target.y };
+  }
+}
+
+// ======= Internals =======
+function rectanglesOverlap(a: Rectangle2D, b: Rectangle2D): boolean {
+  return !(
+    a.x + a.width + MIN_DISTANCE <= b.x ||
+    b.x + b.width + MIN_DISTANCE <= a.x ||
+    a.y + a.height + MIN_DISTANCE <= b.y ||
+    b.y + b.height + MIN_DISTANCE <= a.y
+  );
+}
+
+function rectanglesStrictOverlap(a: Rectangle2D, b: Rectangle2D): boolean {
+  return !(a.x + a.width <= b.x || b.x + b.width <= a.x || a.y + a.height <= b.y || b.y + b.height <= a.y);
+}
+
+function preventOverlap(
+  target: Rectangle2D,
+  fixedRectangles: Rectangle2D[],
+  options: { moveX?: boolean; moveY?: boolean } = { moveX: true, moveY: true }
+) {
+  if ((!options.moveX && !options.moveY) || fixedRectangles.length === 0) {
+    return;
+  }
+  let hasOverlap: boolean;
+  do {
+    hasOverlap = false;
+    for (const fixed of fixedRectangles) {
+      if (rectanglesOverlap(target, fixed)) {
+        hasOverlap = true;
+        if (options.moveX) {
+          target.x += MIN_DISTANCE;
+        }
+        if (options.moveY) {
+          target.y += MIN_DISTANCE;
+        }
+        break;
+      }
+    }
+  } while (hasOverlap);
+}
+
+function calculatePositionFromArgs(args: NodePosition[]): Position2D {
+  const maxY = Math.max(...args.map(node => node.y));
+  const minX = Math.min(...args.map(node => node.x));
+  const maxX = Math.max(...args.map(node => node.x));
+  return {
+    x: Math.ceil((maxX + minX) / 2 / GRID_SIZE) * GRID_SIZE,
+    y: maxY + 2 * OPERATION_NODE_HEIGHT + MIN_DISTANCE
+  };
+}
+
+function calculatePositionFromChildren(
+  initial: Rectangle2D,
+  operations: NodePosition[],
+  blocks: NodePosition[]
+): Rectangle2D {
+  const allNodes = [...blocks, ...operations];
+  if (allNodes.length === 0) {
+    return initial;
+  }
+
+  const left = Math.min(...allNodes.map(n => n.x)) - MIN_DISTANCE;
+  const top = Math.min(...allNodes.map(n => n.y)) - MIN_DISTANCE;
+  const right = Math.max(...allNodes.map(n => n.x + n.width)) + MIN_DISTANCE;
+  const bottom = Math.max(...allNodes.map(n => n.y + n.height)) + MIN_DISTANCE;
+
+  return {
+    x: left,
+    y: top,
+    width: right - left,
+    height: bottom - top
+  };
+}
+
+function findClosestNodeByDistance(nodes: NodePosition[], target: NodePosition): NodePosition | null {
+  let minDist = Infinity;
+  let minNode = null;
+  for (const curr of nodes) {
+    const currDist = Math.hypot(curr.x - target.x, curr.y - target.y);
+    if (currDist < minDist) {
+      minDist = currDist;
+      minNode = curr;
+    }
+  }
+  return minNode;
+}

package/src/library/oss-layout.ts

@@ -0,0 +1,27 @@
+/**
+ * Module: OSS graphical representation.
+ */
+
+/** Represents XY Position. */
+export interface Position2D {
+  x: number;
+  y: number;
+}
+
+/** Represents XY Position and dimensions. */
+export interface Rectangle2D extends Position2D {
+  width: number;
+  height: number;
+}
+
+/** Represents a node in {@link OssLayout}. */
+export interface NodePosition {
+  nodeID: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+
+/** Represents {@link OperationSchema} layout. */
+export type OssLayout = NodePosition[];

package/src/library/oss.ts

@@ -0,0 +1,150 @@
+/**
+ * Module: Schema of Synthesis Operations.
+ */
+
+import { type Graph } from '../graph';
+
+import { type LibraryItem } from './library';
+import { type NodePosition, type OssLayout } from './oss-layout';
+
+/** Represents OSS node type. */
+export const NodeType = {
+  OPERATION: 1,
+  BLOCK: 2
+} as const;
+export type NodeType = (typeof NodeType)[keyof typeof NodeType];
+
+/** Represents OSS graph node. */
+interface OssNode extends NodePosition {
+  nodeType: NodeType;
+  parent: number | null;
+}
+
+/** Represents {@link Operation} type. */
+export const OperationType = {
+  INPUT: 'input',
+  SYNTHESIS: 'synthesis',
+  REPLICA: 'replica'
+} as const;
+export type OperationType = (typeof OperationType)[keyof typeof OperationType];
+
+/** Represents {@link Substitution} extended data. */
+export interface CstSubstituteInfo {
+  original: number;
+  substitution: number;
+  operation: number;
+  original_schema: number;
+  original_alias: string;
+  original_term: string;
+  substitution_schema: number;
+  substitution_alias: string;
+  substitution_term: string;
+}
+
+/** Represents Operation common attributes. */
+interface OperationBase extends OssNode {
+  id: number;
+  alias: string;
+  title: string;
+  description: string;
+  operation_type: OperationType;
+  result: number | null;
+  nodeType: typeof NodeType.OPERATION;
+  has_additions: boolean;
+}
+
+/** Represents Input Operation. */
+export interface OperationInput extends OperationBase {
+  operation_type: typeof OperationType.INPUT;
+  is_import: boolean;
+}
+
+/** Represents Replica Operation. */
+interface OperationReplica extends OperationBase {
+  operation_type: typeof OperationType.REPLICA;
+  target: number;
+}
+
+/** Represents Synthesis Operation. */
+export interface OperationSynthesis extends OperationBase {
+  operation_type: typeof OperationType.SYNTHESIS;
+  is_consolidation: boolean; // aka 'diamond synthesis'
+  substitutions: CstSubstituteInfo[];
+  arguments: number[];
+}
+
+/** Represents Operation. */
+export type Operation = OperationInput | OperationReplica | OperationSynthesis;
+
+/** Represents Block. */
+export interface Block extends OssNode {
+  id: number;
+  oss: number;
+  title: string;
+  description: string;
+  parent: number | null;
+  nodeType: typeof NodeType.BLOCK;
+}
+
+/** Represents item of OperationSchema. */
+export type OssItem = Operation | Block;
+
+/** Represents {@link OperationSchema} statistics. */
+export interface OperationSchemaStats {
+  count_all: number;
+  count_inputs: number;
+  count_synthesis: number;
+  count_schemas: number;
+  count_owned: number;
+  count_block: number;
+  count_references: number;
+}
+
+/** Represents OperationSchema. */
+export interface OperationSchema extends LibraryItem {
+  editors: number[];
+  operations: Operation[];
+  blocks: Block[];
+  replicas: {
+    original: number;
+    replica: number;
+  }[];
+  layout: OssLayout;
+  arguments: {
+    operation: number;
+    argument: number;
+  }[];
+  substitutions: CstSubstituteInfo[];
+
+  graph: Graph;
+  extendedGraph: Graph;
+  hierarchy: Graph<string>;
+  schemas: number[];
+  stats: OperationSchemaStats;
+  operationByID: Map<number, Operation>;
+  blockByID: Map<number, Block>;
+  itemByNodeID: Map<string, OssItem>;
+}
+
+/** Represents substitution error description. */
+export interface SubstitutionErrorDescription {
+  errorType: SubstitutionErrorType;
+  params: string[];
+}
+
+/** Represents Substitution table error types. */
+export const SubstitutionErrorType = {
+  invalidIDs: 0,
+  incorrectCst: 1,
+  invalidClasses: 2,
+  invalidBasic: 3,
+  invalidConstant: 4,
+  typificationCycle: 5,
+  baseSubstitutionNotSet: 6,
+  unequalTypification: 7,
+  unequalExpressions: 8,
+  unequalArgsCount: 9,
+  unequalArgs: 10,
+  invalidNominal: 11
+} as const;
+export type SubstitutionErrorType = (typeof SubstitutionErrorType)[keyof typeof SubstitutionErrorType];