@yuzhouu/canvas-kit 0.1.2

package/_vendor/canvas-core/editor/managers/queryState.ts

@@ -0,0 +1,583 @@
+import type { RecordUpdate, StoreChange } from "@land/store";
+import {
+  type BindingId,
+  type BindingRecord,
+  type EditorRecord,
+  isBindingRecord,
+  isPageRecord,
+  isShapeRecord,
+  type PageId,
+  type ShapeId,
+  type ShapeParentId,
+  type ShapeRecord,
+} from "../../schema/records";
+
+export interface QueryState {
+  pageShapeIdsByPage: Map<PageId, ShapeId[]>;
+  childShapeIdsByParent: Map<ShapeParentId, ShapeId[]>;
+  pageIdByShape: Map<ShapeId, PageId>;
+  bindingById: Map<BindingId, BindingRecord>;
+  bindingIdsByFromShape: Map<ShapeId, BindingId[]>;
+  bindingIdsByToShape: Map<ShapeId, BindingId[]>;
+  relatedBindingIdsByShape: Map<ShapeId, BindingId[]>;
+}
+
+type ReadEditorRecord = (id: string) => EditorRecord | undefined;
+
+function pushShapeId<Key extends string>(
+  map: Map<Key, ShapeId[]>,
+  key: Key,
+  shapeId: ShapeId,
+): void {
+  const ids = map.get(key);
+  if (ids) {
+    ids.push(shapeId);
+    return;
+  }
+  map.set(key, [shapeId]);
+}
+
+function pushBindingId<Key extends string>(
+  map: Map<Key, BindingId[]>,
+  key: Key,
+  bindingId: BindingId,
+): void {
+  const ids = map.get(key);
+  if (ids) {
+    ids.push(bindingId);
+    return;
+  }
+  map.set(key, [bindingId]);
+}
+
+function removeIdFromMap<Key extends string, TId extends string>(
+  map: Map<Key, TId[]>,
+  key: Key,
+  id: TId,
+): boolean {
+  const currentIds = map.get(key);
+  if (!currentIds) {
+    return false;
+  }
+
+  const index = currentIds.indexOf(id);
+  if (index < 0) {
+    return false;
+  }
+
+  if (currentIds.length === 1) {
+    map.delete(key);
+    return true;
+  }
+
+  const nextIds = currentIds.slice();
+  nextIds.splice(index, 1);
+  map.set(key, nextIds);
+  return true;
+}
+
+export function areShapeIdArraysEqual(a: ShapeId[], b: ShapeId[]): boolean {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function compareShapeIndex(left: ShapeRecord, right: ShapeRecord): number {
+  return left.index.localeCompare(right.index);
+}
+
+export function compareBindings(
+  left: BindingRecord,
+  right: BindingRecord,
+): number {
+  if (left.fromId === right.fromId) {
+    return left.id.localeCompare(right.id);
+  }
+
+  return left.fromId.localeCompare(right.fromId);
+}
+
+function compareBindingForRelation(
+  relation: "from" | "to" | "related",
+  left: BindingRecord,
+  right: BindingRecord,
+): number {
+  if (relation === "to") {
+    if (left.toId === right.toId) {
+      if (left.fromId === right.fromId) {
+        return left.id.localeCompare(right.id);
+      }
+      return left.fromId.localeCompare(right.fromId);
+    }
+
+    return left.toId.localeCompare(right.toId);
+  }
+
+  return compareBindings(left, right);
+}
+
+function findBindingInsertIndex(
+  bindingIds: BindingId[],
+  binding: BindingRecord,
+  relation: "from" | "to" | "related",
+  getBinding: (id: BindingId) => BindingRecord | undefined,
+): number {
+  for (let index = 0; index < bindingIds.length; index += 1) {
+    const currentBinding = getBinding(bindingIds[index]!);
+    if (
+      currentBinding &&
+      compareBindingForRelation(relation, binding, currentBinding) < 0
+    ) {
+      return index;
+    }
+  }
+
+  return bindingIds.length;
+}
+
+function insertBindingId<Key extends string>(
+  map: Map<Key, BindingId[]>,
+  key: Key,
+  binding: BindingRecord,
+  relation: "from" | "to" | "related",
+  getBinding: (id: BindingId) => BindingRecord | undefined,
+): boolean {
+  const currentIds = map.get(key);
+  if (!currentIds) {
+    map.set(key, [binding.id]);
+    return true;
+  }
+
+  if (currentIds.includes(binding.id)) {
+    return false;
+  }
+
+  const nextIds = currentIds.slice();
+  nextIds.splice(
+    findBindingInsertIndex(currentIds, binding, relation, getBinding),
+    0,
+    binding.id,
+  );
+  map.set(key, nextIds);
+  return true;
+}
+
+function insertShapeIdSorted(
+  map: Map<ShapeParentId, ShapeId[]>,
+  parentId: ShapeParentId,
+  shape: ShapeRecord,
+  resolveIndex: (id: ShapeId) => string | undefined,
+): void {
+  const ids = map.get(parentId);
+  if (!ids) {
+    map.set(parentId, [shape.id]);
+    return;
+  }
+  if (ids.includes(shape.id)) {
+    return;
+  }
+  let insertAt = ids.length;
+  for (let i = 0; i < ids.length; i += 1) {
+    const siblingIndex = resolveIndex(ids[i]!);
+    if (
+      siblingIndex !== undefined &&
+      siblingIndex.localeCompare(shape.index) > 0
+    ) {
+      insertAt = i;
+      break;
+    }
+  }
+  const next = ids.slice();
+  next.splice(insertAt, 0, shape.id);
+  map.set(parentId, next);
+}
+
+function removeShapeIdFromParent(
+  map: Map<ShapeParentId, ShapeId[]>,
+  parentId: ShapeParentId,
+  shapeId: ShapeId,
+): void {
+  removeIdFromMap(map, parentId, shapeId);
+}
+
+function isShapeUpdate(
+  update: RecordUpdate<EditorRecord>,
+): update is RecordUpdate<ShapeRecord> {
+  return isShapeRecord(update.before) && isShapeRecord(update.after);
+}
+
+function isBindingUpdate(
+  update: RecordUpdate<EditorRecord>,
+): update is RecordUpdate<BindingRecord> {
+  return isBindingRecord(update.before) && isBindingRecord(update.after);
+}
+
+export function buildQueryState(records: EditorRecord[]): QueryState {
+  const pages = records.filter(isPageRecord).sort((left, right) =>
+    left.index.localeCompare(right.index),
+  );
+  const shapes = records.filter(isShapeRecord).sort((left, right) => {
+    if (left.parentId === right.parentId) {
+      return compareShapeIndex(left, right);
+    }
+
+    return left.parentId.localeCompare(right.parentId);
+  });
+  const bindings = records.filter(isBindingRecord).sort(compareBindings);
+
+  const pageShapeIdsByPage = new Map<PageId, ShapeId[]>();
+  const childShapeIdsByParent = new Map<ShapeParentId, ShapeId[]>();
+  const pageIdByShape = new Map<ShapeId, PageId>();
+  const shapeById = new Map(shapes.map((shape) => [shape.id, shape]));
+  const bindingById = new Map<BindingId, BindingRecord>();
+  const bindingIdsByFromShape = new Map<ShapeId, BindingId[]>();
+  const bindingIdsByToShape = new Map<ShapeId, BindingId[]>();
+  const relatedBindingIdsByShape = new Map<ShapeId, BindingId[]>();
+
+  for (const shape of shapes) {
+    pushShapeId(childShapeIdsByParent, shape.parentId, shape.id);
+  }
+
+  const collectPageShapeIds = (pageId: PageId, parentId: ShapeParentId) => {
+    for (const childId of childShapeIdsByParent.get(parentId) ?? []) {
+      const child = shapeById.get(childId);
+      if (!child) {
+        continue;
+      }
+
+      pushShapeId(pageShapeIdsByPage, pageId, child.id);
+      pageIdByShape.set(child.id, pageId);
+      collectPageShapeIds(pageId, child.id);
+    }
+  };
+
+  for (const page of pages) {
+    collectPageShapeIds(page.id, page.id);
+  }
+
+  for (const binding of bindings) {
+    bindingById.set(binding.id, binding);
+    pushBindingId(bindingIdsByFromShape, binding.fromId, binding.id);
+    pushBindingId(bindingIdsByToShape, binding.toId, binding.id);
+    pushBindingId(relatedBindingIdsByShape, binding.fromId, binding.id);
+    pushBindingId(relatedBindingIdsByShape, binding.toId, binding.id);
+  }
+
+  return {
+    pageShapeIdsByPage,
+    childShapeIdsByParent,
+    pageIdByShape,
+    bindingById,
+    bindingIdsByFromShape,
+    bindingIdsByToShape,
+    relatedBindingIdsByShape,
+  } satisfies QueryState;
+}
+
+export function getRemovedShapeIdsFromQueryStateChange(
+  change: StoreChange<EditorRecord>,
+): ShapeId[] {
+  return change.diff.removed.filter(isShapeRecord).map((shape) => shape.id);
+}
+
+export function updateQueryStateFromStoreChange(
+  previous: QueryState,
+  change: StoreChange<EditorRecord>,
+  getRecord: ReadEditorRecord,
+): QueryState {
+  const addedShapes = change.diff.added.filter(isShapeRecord);
+  const updatedShapes = change.diff.updated.filter(isShapeUpdate);
+  const removedShapes = change.diff.removed.filter(isShapeRecord);
+
+  const addedBindings = change.diff.added.filter(isBindingRecord);
+  const updatedBindings = change.diff.updated.filter(isBindingUpdate);
+  const removedBindings = change.diff.removed.filter(isBindingRecord);
+
+  const hasStructuralShapeChange =
+    addedShapes.length > 0 ||
+    removedShapes.length > 0 ||
+    updatedShapes.some(
+      ({ before, after }) =>
+        before.parentId !== after.parentId || before.index !== after.index,
+    );
+  const hasBindingIndexChange =
+    addedBindings.length > 0 ||
+    removedBindings.length > 0 ||
+    updatedBindings.some(
+      ({ before, after }) =>
+        before.fromId !== after.fromId || before.toId !== after.toId,
+    );
+  const hasBindingRecordChange =
+    addedBindings.length > 0 ||
+    removedBindings.length > 0 ||
+    updatedBindings.length > 0;
+
+  if (!hasStructuralShapeChange && !hasBindingRecordChange) {
+    return previous;
+  }
+
+  const next: QueryState = {
+    pageShapeIdsByPage: new Map(previous.pageShapeIdsByPage),
+    childShapeIdsByParent: new Map(previous.childShapeIdsByParent),
+    pageIdByShape: new Map(previous.pageIdByShape),
+    bindingById: new Map(previous.bindingById),
+    bindingIdsByFromShape: new Map(previous.bindingIdsByFromShape),
+    bindingIdsByToShape: new Map(previous.bindingIdsByToShape),
+    relatedBindingIdsByShape: new Map(previous.relatedBindingIdsByShape),
+  };
+  let didChange = false;
+
+  if (hasStructuralShapeChange) {
+    const resolveIndex = (id: ShapeId): string | undefined => {
+      const record = getRecord(id);
+      return isShapeRecord(record) ? record.index : undefined;
+    };
+    const affectedPages = new Set<PageId>();
+
+    const resolvePageFromStore = (parentId: ShapeParentId): PageId | null => {
+      let current: ShapeParentId | undefined = parentId;
+      const guard = new Set<ShapeParentId>();
+      while (current && !guard.has(current)) {
+        guard.add(current);
+        const record = getRecord(current);
+        if (!record) return null;
+        if (isPageRecord(record)) return record.id;
+        if (isShapeRecord(record)) {
+          current = record.parentId;
+          continue;
+        }
+        return null;
+      }
+      return null;
+    };
+
+    for (const shape of removedShapes) {
+      removeShapeIdFromParent(
+        next.childShapeIdsByParent,
+        shape.parentId,
+        shape.id,
+      );
+      const page = previous.pageIdByShape.get(shape.id);
+      if (page) affectedPages.add(page);
+    }
+
+    for (const { before, after } of updatedShapes) {
+      if (before.parentId === after.parentId && before.index === after.index) {
+        continue;
+      }
+      removeShapeIdFromParent(
+        next.childShapeIdsByParent,
+        before.parentId,
+        before.id,
+      );
+      insertShapeIdSorted(
+        next.childShapeIdsByParent,
+        after.parentId,
+        after,
+        resolveIndex,
+      );
+      const oldPage = previous.pageIdByShape.get(before.id);
+      if (oldPage) affectedPages.add(oldPage);
+      const newPage = resolvePageFromStore(after.parentId);
+      if (newPage) affectedPages.add(newPage);
+    }
+
+    for (const shape of addedShapes) {
+      insertShapeIdSorted(
+        next.childShapeIdsByParent,
+        shape.parentId,
+        shape,
+        resolveIndex,
+      );
+    }
+    for (const shape of addedShapes) {
+      const page = resolvePageFromStore(shape.parentId);
+      if (page) affectedPages.add(page);
+    }
+
+    if (affectedPages.size > 0) {
+      const pageShapeIdsByPage = new Map(previous.pageShapeIdsByPage);
+      const pageIdByShape = new Map(previous.pageIdByShape);
+
+      for (const [shapeId, pageId] of previous.pageIdByShape) {
+        if (affectedPages.has(pageId)) {
+          pageIdByShape.delete(shapeId);
+        }
+      }
+
+      const walk = (pageId: PageId, parentId: ShapeParentId): ShapeId[] => {
+        const collected: ShapeId[] = [];
+        for (const childId of next.childShapeIdsByParent.get(parentId) ?? []) {
+          if (!getRecord(childId)) continue;
+          collected.push(childId);
+          pageIdByShape.set(childId, pageId);
+          collected.push(...walk(pageId, childId));
+        }
+        return collected;
+      };
+
+      for (const pageId of affectedPages) {
+        const ids = walk(pageId, pageId);
+        if (ids.length > 0) {
+          pageShapeIdsByPage.set(pageId, ids);
+        } else {
+          pageShapeIdsByPage.delete(pageId);
+        }
+      }
+
+      next.pageShapeIdsByPage = pageShapeIdsByPage;
+      next.pageIdByShape = pageIdByShape;
+    }
+
+    didChange = true;
+  }
+
+  if (hasBindingRecordChange) {
+    for (const binding of removedBindings) {
+      didChange = next.bindingById.delete(binding.id) || didChange;
+    }
+
+    if (hasBindingIndexChange) {
+      for (const binding of removedBindings) {
+        didChange =
+          removeIdFromMap(
+            next.bindingIdsByFromShape,
+            binding.fromId,
+            binding.id,
+          ) || didChange;
+        didChange =
+          removeIdFromMap(
+            next.bindingIdsByToShape,
+            binding.toId,
+            binding.id,
+          ) || didChange;
+        didChange =
+          removeIdFromMap(
+            next.relatedBindingIdsByShape,
+            binding.fromId,
+            binding.id,
+          ) || didChange;
+        didChange =
+          removeIdFromMap(
+            next.relatedBindingIdsByShape,
+            binding.toId,
+            binding.id,
+          ) || didChange;
+      }
+      for (const { before, after } of updatedBindings) {
+        if (before.fromId !== after.fromId || before.toId !== after.toId) {
+          didChange =
+            removeIdFromMap(
+              next.bindingIdsByFromShape,
+              before.fromId,
+              before.id,
+            ) || didChange;
+          didChange =
+            removeIdFromMap(next.bindingIdsByToShape, before.toId, before.id) ||
+            didChange;
+          didChange =
+            removeIdFromMap(
+              next.relatedBindingIdsByShape,
+              before.fromId,
+              before.id,
+            ) || didChange;
+          didChange =
+            removeIdFromMap(
+              next.relatedBindingIdsByShape,
+              before.toId,
+              before.id,
+            ) || didChange;
+        }
+      }
+    }
+
+    for (const binding of addedBindings) {
+      next.bindingById.set(binding.id, binding);
+      didChange = true;
+    }
+    for (const { after } of updatedBindings) {
+      next.bindingById.set(after.id, after);
+      didChange = true;
+    }
+
+    if (hasBindingIndexChange) {
+      for (const binding of addedBindings) {
+        didChange =
+          insertBindingId(
+            next.bindingIdsByFromShape,
+            binding.fromId,
+            binding,
+            "from",
+            (bindingId) => next.bindingById.get(bindingId),
+          ) || didChange;
+        didChange =
+          insertBindingId(
+            next.bindingIdsByToShape,
+            binding.toId,
+            binding,
+            "to",
+            (bindingId) => next.bindingById.get(bindingId),
+          ) || didChange;
+        didChange =
+          insertBindingId(
+            next.relatedBindingIdsByShape,
+            binding.fromId,
+            binding,
+            "related",
+            (bindingId) => next.bindingById.get(bindingId),
+          ) || didChange;
+        didChange =
+          insertBindingId(
+            next.relatedBindingIdsByShape,
+            binding.toId,
+            binding,
+            "related",
+            (bindingId) => next.bindingById.get(bindingId),
+          ) || didChange;
+      }
+      for (const { before, after } of updatedBindings) {
+        if (before.fromId !== after.fromId || before.toId !== after.toId) {
+          didChange =
+            insertBindingId(
+              next.bindingIdsByFromShape,
+              after.fromId,
+              after,
+              "from",
+              (bindingId) => next.bindingById.get(bindingId),
+            ) || didChange;
+          didChange =
+            insertBindingId(
+              next.bindingIdsByToShape,
+              after.toId,
+              after,
+              "to",
+              (bindingId) => next.bindingById.get(bindingId),
+            ) || didChange;
+          didChange =
+            insertBindingId(
+              next.relatedBindingIdsByShape,
+              after.fromId,
+              after,
+              "related",
+              (bindingId) => next.bindingById.get(bindingId),
+            ) || didChange;
+          didChange =
+            insertBindingId(
+              next.relatedBindingIdsByShape,
+              after.toId,
+              after,
+              "related",
+              (bindingId) => next.bindingById.get(bindingId),
+            ) || didChange;
+        }
+      }
+    }
+  }
+
+  return didChange ? next : previous;
+}