@yuzhouu/canvas-kit 0.1.2 → 0.1.3

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

@@ -1,583 +0,0 @@
-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;
-}