@hoox-sh/pynets 0.2.0 → 0.4.0

package/src/runtime/drawings.ts

@@ -69,6 +69,37 @@ function cellKey(column: unknown, row: unknown): string | undefined {
   return `${column},${row}`;
 }
 
+function asIndex(value: unknown): number | null {
+  if (!isFiniteNumber(value)) return null;
+  return Math.trunc(value);
+}
+
+function parseCellKey(key: string): { col: number; row: number } | undefined {
+  const comma = key.indexOf(",");
+  if (comma < 0) return undefined;
+  const col = Number(key.slice(0, comma));
+  const row = Number(key.slice(comma + 1));
+  if (!isFiniteNumber(col) || !isFiniteNumber(row)) return undefined;
+  return { col, row };
+}
+
+function cloneExtra(extra?: Record<string, unknown>): Record<string, unknown> | undefined {
+  if (extra == null) return undefined;
+  const out: Record<string, unknown> = { ...extra };
+  if (out.cells != null && typeof out.cells === "object" && !Array.isArray(out.cells)) {
+    const cells: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(out.cells as Record<string, unknown>)) {
+      cells[k] = v != null && typeof v === "object" && !Array.isArray(v) ? { ...(v as Record<string, unknown>) } : v;
+    }
+    out.cells = cells;
+  }
+  if (Array.isArray(out.points)) {
+    out.points = out.points.map((p) => (p != null && typeof p === "object" ? { ...(p as Record<string, unknown>) } : p));
+  }
+  if (Array.isArray(out.merged)) out.merged = out.merged.slice();
+  return out;
+}
+
 export class DrawingBook {
   readonly items: DrawingEvent[] = [];
   private readonly byId = new Map<number, DrawingEvent>();
@@ -110,24 +141,33 @@ export class DrawingBook {
     return this.items.filter((e) => e.kind === kind && !e.deleted);
   }
 
+  /** Insertion-order ids of non-deleted objects of *kind* (Python `*.all`). */
+  allIds(kind: DrawingKind): number[] {
+    const ids: number[] = [];
+    for (const [id, ev] of this.byId) {
+      if (ev.kind === kind && !ev.deleted) ids.push(id);
+    }
+    return ids;
+  }
+
   lineNew(bar: number, extra?: Record<string, unknown>): number {
     return this.push("line", bar, { extra, cap: this.maxLines });
   }
 
-  labelNew(bar: number, text?: string): number {
-    return this.push("label", bar, { text, cap: this.maxLabels });
+  labelNew(bar: number, text?: string, extra?: Record<string, unknown>): number {
+    return this.push("label", bar, { text, extra, cap: this.maxLabels });
   }
 
-  boxNew(bar: number): number {
-    return this.push("box", bar, { cap: this.maxBoxes });
+  boxNew(bar: number, extra?: Record<string, unknown>): number {
+    return this.push("box", bar, { extra, cap: this.maxBoxes });
   }
 
-  tableNew(bar: number): number {
-    return this.push("table", bar);
+  tableNew(bar: number, extra?: Record<string, unknown>): number {
+    return this.push("table", bar, { extra });
   }
 
-  polylineNew(bar: number): number {
-    return this.push("polyline", bar, { cap: this.maxPolylines });
+  polylineNew(bar: number, extra?: Record<string, unknown>): number {
+    return this.push("polyline", bar, { extra, cap: this.maxPolylines });
   }
 
   linefillNew(bar: number, extraOrId1?: Record<string, unknown> | number, id2?: number): number {
@@ -364,6 +404,326 @@ export class DrawingBook {
     setAny(extra, "color", color);
   }
 
+  lineSetX1(id: number, x1: unknown): void {
+    this.setKindNum(id, "line", "x1", x1);
+  }
+
+  lineSetY1(id: number, y1: unknown): void {
+    this.setKindNum(id, "line", "y1", y1);
+  }
+
+  lineSetX2(id: number, x2: unknown): void {
+    this.setKindNum(id, "line", "x2", x2);
+  }
+
+  lineSetY2(id: number, y2: unknown): void {
+    this.setKindNum(id, "line", "y2", y2);
+  }
+
+  lineSetXloc(id: number, xloc: unknown): void {
+    this.setKindAny(id, "line", "xloc", xloc);
+  }
+
+  boxGetLeft(id: number): number | null {
+    return this.kindNum(id, "box", "left");
+  }
+
+  boxGetRight(id: number): number | null {
+    return this.kindNum(id, "box", "right");
+  }
+
+  boxGetTop(id: number): number | null {
+    return this.kindNum(id, "box", "top");
+  }
+
+  boxGetBottom(id: number): number | null {
+    return this.kindNum(id, "box", "bottom");
+  }
+
+  boxSetLeft(id: number, left: unknown): void {
+    this.setKindNum(id, "box", "left", left);
+  }
+
+  boxSetRight(id: number, right: unknown): void {
+    this.setKindNum(id, "box", "right", right);
+  }
+
+  boxSetTop(id: number, top: unknown): void {
+    this.setKindNum(id, "box", "top", top);
+  }
+
+  boxSetBottom(id: number, bottom: unknown): void {
+    this.setKindNum(id, "box", "bottom", bottom);
+  }
+
+  boxSetLeftTop(id: number, left: unknown, top: unknown): void {
+    const extra = this.extraOf(id, "box");
+    if (!extra) return;
+    setNum(extra, "left", left);
+    setNum(extra, "top", top);
+  }
+
+  boxSetRightBottom(id: number, right: unknown, bottom: unknown): void {
+    const extra = this.extraOf(id, "box");
+    if (!extra) return;
+    setNum(extra, "right", right);
+    setNum(extra, "bottom", bottom);
+  }
+
+  boxSetBorderWidth(id: number, width: unknown): void {
+    this.setKindNum(id, "box", "border_width", width);
+  }
+
+  boxSetBorderStyle(id: number, style: unknown): void {
+    this.setKindAny(id, "box", "border_style", style);
+  }
+
+  boxSetXloc(id: number, xloc: unknown): void {
+    this.setKindAny(id, "box", "xloc", xloc);
+  }
+
+  boxSetClosed(id: number, closed: unknown): void {
+    this.setKindAny(id, "box", "closed", closed);
+  }
+
+  boxSetTextColor(id: number, color: unknown): void {
+    this.setKindAny(id, "box", "text_color", color);
+  }
+
+  boxSetTextFontFamily(id: number, font: unknown): void {
+    this.setKindAny(id, "box", "text_font_family", font);
+  }
+
+  boxSetTextHalign(id: number, halign: unknown): void {
+    this.setKindAny(id, "box", "text_halign", halign);
+  }
+
+  boxSetTextValign(id: number, valign: unknown): void {
+    this.setKindAny(id, "box", "text_valign", valign);
+  }
+
+  boxSetTextSize(id: number, size: unknown): void {
+    this.setKindAny(id, "box", "text_size", size);
+  }
+
+  boxSetTextFormatting(id: number, formatting: unknown): void {
+    this.setKindAny(id, "box", "text_formatting", formatting);
+  }
+
+  boxSetTextWrap(id: number, wrap: unknown): void {
+    this.setKindAny(id, "box", "text_wrap", wrap);
+  }
+
+  labelSetX(id: number, x: unknown): void {
+    this.setKindNum(id, "label", "x", x);
+  }
+
+  labelSetY(id: number, y: unknown): void {
+    this.setKindNum(id, "label", "y", y);
+  }
+
+  labelSetTextcolor(id: number, color: unknown): void {
+    this.setKindAny(id, "label", "textcolor", color);
+  }
+
+  labelSetTextFontFamily(id: number, font: unknown): void {
+    this.setKindAny(id, "label", "text_font_family", font);
+  }
+
+  labelSetTextHalign(id: number, halign: unknown): void {
+    this.setKindAny(id, "label", "text_halign", halign);
+  }
+
+  labelSetTextValign(id: number, valign: unknown): void {
+    this.setKindAny(id, "label", "text_valign", valign);
+  }
+
+  labelSetTextSize(id: number, size: unknown): void {
+    this.setKindAny(id, "label", "text_size", size);
+  }
+
+  labelSetTextFormatting(id: number, formatting: unknown): void {
+    this.setKindAny(id, "label", "text_formatting", formatting);
+  }
+
+  labelSetBorderColor(id: number, color: unknown): void {
+    this.setKindAny(id, "label", "border_color", color);
+  }
+
+  labelSetBorderWidth(id: number, width: unknown): void {
+    this.setKindNum(id, "label", "border_width", width);
+  }
+
+  labelSetBorderStyle(id: number, style: unknown): void {
+    this.setKindAny(id, "label", "border_style", style);
+  }
+
+  labelSetXloc(id: number, xloc: unknown): void {
+    this.setKindAny(id, "label", "xloc", xloc);
+  }
+
+  labelSetYloc(id: number, yloc: unknown): void {
+    this.setKindAny(id, "label", "yloc", yloc);
+  }
+
+  tableCellGetText(id: number, column: unknown, row: unknown): string | null {
+    const rec = this.cellRec(id, column, row);
+    if (!rec) return null;
+    if (rec.text === undefined) return null;
+    return rec.text == null ? "" : String(rec.text);
+  }
+
+  tableCellSetField(id: number, column: unknown, row: unknown, field: string, value: unknown): void {
+    this.upsertCell(id, column, row, undefined, false);
+    const rec = this.cellRec(id, column, row);
+    if (!rec) return;
+    rec[field] = value;
+  }
+
+  tableSetBgcolor(id: number, color: unknown): void {
+    this.setKindAny(id, "table", "bgcolor", color);
+  }
+
+  tableSetBorderColor(id: number, color: unknown): void {
+    this.setKindAny(id, "table", "border_color", color);
+  }
+
+  tableSetBorderWidth(id: number, width: unknown): void {
+    this.setKindNum(id, "table", "border_width", width);
+  }
+
+  tableSetFrameColor(id: number, color: unknown): void {
+    this.setKindAny(id, "table", "frame_color", color);
+  }
+
+  tableSetFrameWidth(id: number, width: unknown): void {
+    this.setKindNum(id, "table", "frame_width", width);
+  }
+
+  tableClear(
+    id: number,
+    startRow?: unknown,
+    startCol?: unknown,
+    endRow?: unknown,
+    endCol?: unknown,
+  ): void {
+    const extra = this.extraOf(id, "table");
+    if (!extra) return;
+    if (startRow === undefined) {
+      extra.cells = {};
+      return;
+    }
+    const r0 = asIndex(startRow);
+    const c0 = asIndex(startCol);
+    const r1 = asIndex(endRow);
+    const c1 = asIndex(endCol);
+    if (r0 == null || c0 == null || r1 == null || c1 == null) return;
+    const prev = extra.cells;
+    if (prev == null || typeof prev !== "object" || Array.isArray(prev)) return;
+    const cells = prev as Record<string, unknown>;
+    for (const key of Object.keys(cells)) {
+      const parsed = parseCellKey(key);
+      if (parsed == null) continue;
+      if (r0 <= parsed.row && parsed.row <= r1 && c0 <= parsed.col && parsed.col <= c1) {
+        delete cells[key];
+      }
+    }
+  }
+
+  tableMergeCells(
+    id: number,
+    startRow: unknown,
+    startCol: unknown,
+    endRow: unknown,
+    endCol: unknown,
+  ): void {
+    const extra = this.extraOf(id, "table");
+    if (!extra) return;
+    const r0 = asIndex(startRow);
+    const c0 = asIndex(startCol);
+    const r1 = asIndex(endRow);
+    const c1 = asIndex(endCol);
+    if (r0 == null || c0 == null || r1 == null || c1 == null) return;
+    if (r1 < r0 || c1 < c0) return;
+    const prev = extra.merged;
+    const merged = Array.isArray(prev) ? prev : [];
+    if (merged !== prev) extra.merged = merged;
+    merged.push([r0, c0, r1, c1]);
+  }
+
+  polylineGetPoints(id: number): unknown[] {
+    const ev = this.byId.get(id);
+    if (!ev || ev.kind !== "polyline" || ev.deleted) return [];
+    const pts = ev.extra?.points;
+    return Array.isArray(pts) ? pts.slice() : [];
+  }
+
+  polylineSetPoints(id: number, points: unknown): void {
+    const extra = this.extraOf(id, "polyline");
+    if (!extra) return;
+    extra.points = Array.isArray(points) ? points.filter((p) => p != null) : [];
+  }
+
+  polylineSetLineColor(id: number, color: unknown): void {
+    this.setKindAny(id, "polyline", "color", color);
+  }
+
+  polylineSetLineWidth(id: number, width: unknown): void {
+    this.setKindNum(id, "polyline", "width", width);
+  }
+
+  polylineSetLineStyle(id: number, style: unknown): void {
+    this.setKindAny(id, "polyline", "style", style);
+  }
+
+  polylineSetFillColor(id: number, color: unknown): void {
+    this.setKindAny(id, "polyline", "fill_color", color);
+  }
+
+  polylineSetCurved(id: number, curved: unknown): void {
+    this.setKindAny(id, "polyline", "curved", curved);
+  }
+
+  polylineSetForceOverlay(id: number, force: unknown): void {
+    this.setKindAny(id, "polyline", "force_overlay", force);
+  }
+
+  polylineSetClosed(id: number, closed: unknown): void {
+    this.setKindAny(id, "polyline", "closed", closed);
+  }
+
+  polylineSetXloc(id: number, xloc: unknown): void {
+    this.setKindAny(id, "polyline", "xloc", xloc);
+  }
+
+  linefillGetLine1(id: number): number | null {
+    return this.kindNum(id, "linefill", "id1");
+  }
+
+  linefillGetLine2(id: number): number | null {
+    return this.kindNum(id, "linefill", "id2");
+  }
+
+  tableDelete(id: number): void {
+    this.markDeleted(id);
+  }
+
+  polylineDelete(id: number): void {
+    this.markDeleted(id);
+  }
+
+  linefillDelete(id: number): void {
+    this.markDeleted(id);
+  }
+
+  /** Clone a drawing; missing id → null. New object is not marked deleted. */
+  copy(id: number): number | null {
+    const ev = this.byId.get(id);
+    if (!ev) return null;
+    const extra = cloneExtra(ev.extra);
+    return this.push(ev.kind, ev.bar, { text: ev.text, extra, cap: this.capFor(ev.kind) });
+  }
+
   /** Compact non-deleted items for RuntimeResult.drawings. */
   exportForApi(): Array<{
     kind: DrawingKind;
@@ -420,6 +780,43 @@ export class DrawingBook {
     return id;
   }
 
+  private capFor(kind: DrawingKind): number | undefined {
+    if (kind === "line") return this.maxLines;
+    if (kind === "label") return this.maxLabels;
+    if (kind === "box") return this.maxBoxes;
+    if (kind === "polyline") return this.maxPolylines;
+    return undefined;
+  }
+
+  private setKindNum(id: number, kind: DrawingKind, key: string, value: unknown): void {
+    const extra = this.extraOf(id, kind);
+    if (!extra) return;
+    setNum(extra, key, value);
+  }
+
+  private setKindAny(id: number, kind: DrawingKind, key: string, value: unknown): void {
+    const extra = this.extraOf(id, kind);
+    if (!extra) return;
+    setAny(extra, key, value);
+  }
+
+  private kindNum(id: number, kind: DrawingKind, key: string): number | null {
+    const ev = this.byId.get(id);
+    if (!ev || ev.kind !== kind) return null;
+    return this.extraNum(id, key);
+  }
+
+  private cellRec(id: number, column: unknown, row: unknown): Record<string, unknown> | undefined {
+    const extra = this.extraOf(id, "table");
+    const key = cellKey(column, row);
+    if (!extra || key == null) return undefined;
+    const prev = extra.cells;
+    if (prev == null || typeof prev !== "object" || Array.isArray(prev)) return undefined;
+    const cur = (prev as Record<string, unknown>)[key];
+    if (cur == null || typeof cur !== "object" || Array.isArray(cur)) return undefined;
+    return cur as Record<string, unknown>;
+  }
+
   private extraOf(id: number, kind?: DrawingKind): Record<string, unknown> | undefined {
     const ev = this.byId.get(id);
     if (!ev) return undefined;