@hellixit/hellixitboard 0.1.0

package/dist/types/element/src/duplicate.d.ts

@@ -0,0 +1,63 @@
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type { AppState } from "@hellixit/hellixitboard/types";
+import type { HellixitboardElement, GroupId } from "./types";
+/**
+ * Duplicate an element, often used in the alt-drag operation.
+ * Note that this method has gotten a bit complicated since the
+ * introduction of gruoping/ungrouping elements.
+ * @param editingGroupId The current group being edited. The new
+ *                       element will inherit this group and its
+ *                       parents.
+ * @param groupIdMapForOperation A Map that maps old group IDs to
+ *                               duplicated ones. If you are duplicating
+ *                               multiple elements at once, share this map
+ *                               amongst all of them
+ * @param element Element to duplicate
+ */
+export declare const duplicateElement: <TElement extends HellixitboardElement>(editingGroupId: AppState["editingGroupId"], groupIdMapForOperation: Map<GroupId, GroupId>, element: TElement, randomizeSeed?: boolean) => Readonly<TElement>;
+export declare const duplicateElements: (opts: {
+    elements: readonly HellixitboardElement[];
+    randomizeSeed?: boolean;
+    overrides?: (data: {
+        duplicateElement: HellixitboardElement;
+        origElement: HellixitboardElement;
+        origIdToDuplicateId: Map<HellixitboardElement["id"], HellixitboardElement["id"]>;
+    }) => Partial<HellixitboardElement>;
+} & ({
+    /**
+     * Duplicates all elements in array.
+     *
+     * Use this when programmaticaly duplicating elements, without direct
+     * user interaction.
+     */
+    type: "everything";
+} | {
+    /**
+     * Duplicates specified elements and inserts them back into the array
+     * in specified order.
+     *
+     * Use this when duplicating Scene elements, during user interaction
+     * such as alt-drag or on duplicate action.
+     */
+    type: "in-place";
+    idsOfElementsToDuplicate: Map<HellixitboardElement["id"], HellixitboardElement>;
+    appState: {
+        editingGroupId: AppState["editingGroupId"];
+        selectedGroupIds: AppState["selectedGroupIds"];
+    };
+})) => {
+    duplicatedElements: HellixitboardElement[];
+    duplicateElementsMap: Map<string, HellixitboardElement>;
+    elementsWithDuplicates: HellixitboardElement[];
+    origIdToDuplicateId: Map<string, string>;
+};
+/**
+ * Clones HellixitboardElement data structure. Does not regenerate id, nonce, or
+ * any value. The purpose is to to break object references for immutability
+ * reasons, whenever we want to keep the original element, but ensure it's not
+ * mutated.
+ *
+ * Only clones plain objects and arrays. Doesn't clone Date, RegExp, Map, Set,
+ * Typed arrays and other non-null objects.
+ */
+export declare const deepCopyElement: <T extends HellixitboardElement>(val: T) => Mutable<T>;

package/dist/types/element/src/elbowArrow.d.ts

@@ -0,0 +1,19 @@
+import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
+import { type ElementUpdate } from "./mutateElement";
+import { type HellixitboardElbowArrowElement, type NonDeletedSceneElementsMap } from "./types";
+import type { FixedPointBinding, FixedSegment } from "./types";
+export declare const BASE_PADDING = 40;
+/**
+ *
+ */
+export declare const updateElbowArrowPoints: (arrow: Readonly<HellixitboardElbowArrowElement>, elementsMap: NonDeletedSceneElementsMap, updates: {
+    points?: readonly LocalPoint[];
+    fixedSegments?: readonly FixedSegment[] | null;
+    startBinding?: FixedPointBinding | null;
+    endBinding?: FixedPointBinding | null;
+}, options?: {
+    isDragging?: boolean;
+    isBindingEnabled?: boolean;
+    isMidpointSnappingEnabled?: boolean;
+}) => ElementUpdate<HellixitboardElbowArrowElement>;
+export declare const validateElbowPoints: <P extends GlobalPoint | LocalPoint>(points: readonly P[], tolerance?: number) => boolean;

package/dist/types/element/src/elementLink.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Create and link between shapes.
+ */
+import type { AppProps, AppState } from "@hellixit/hellixitboard/types";
+import type { HellixitboardElement } from "./types";
+export declare const defaultGetElementLinkFromSelection: Exclude<AppProps["generateLinkForSelection"], undefined>;
+export declare const getLinkIdAndTypeFromSelection: (selectedElements: HellixitboardElement[], appState: AppState) => {
+    id: string;
+    type: "element" | "group";
+} | null;
+export declare const canCreateLinkFromElements: (selectedElements: HellixitboardElement[]) => boolean;
+export declare const isElementLink: (url: string) => boolean;
+export declare const parseElementLinkFromURL: (url: string) => string | null;

package/dist/types/element/src/embeddable.d.ts

@@ -0,0 +1,10 @@
+import type { HellixitboardProps } from "@hellixit/hellixitboard/types";
+import type { MarkRequired } from "@excalidraw/common/utility-types";
+import type { HellixitboardElement, HellixitboardIframeLikeElement, IframeData } from "./types";
+type IframeDataWithSandbox = MarkRequired<IframeData, "sandbox">;
+export declare const createSrcDoc: (body: string) => string;
+export declare const getEmbedLink: (link: string | null | undefined) => IframeDataWithSandbox | null;
+export declare const createPlaceholderEmbeddableLabel: (element: HellixitboardIframeLikeElement) => HellixitboardElement;
+export declare const maybeParseEmbedSrc: (str: string) => string;
+export declare const embeddableURLValidator: (url: string | null | undefined, validateEmbeddable: HellixitboardProps["validateEmbeddable"]) => boolean;
+export {};

package/dist/types/element/src/flowchart.d.ts

@@ -0,0 +1,26 @@
+import type { AppState, PendingHellixitboardElements } from "@hellixit/hellixitboard/types";
+import { type ElementsMap, type HellixitboardBindableElement, type HellixitboardElement, type HellixitboardFlowchartNodeElement } from "./types";
+import type { Scene } from "./Scene";
+type LinkDirection = "up" | "right" | "down" | "left";
+export declare const getLinkDirectionFromKey: (key: string) => LinkDirection;
+export declare const getPredecessors: (node: HellixitboardBindableElement, elementsMap: ElementsMap, direction: LinkDirection) => HellixitboardBindableElement[];
+export declare const addNewNodes: (startNode: HellixitboardFlowchartNodeElement, appState: AppState, direction: LinkDirection, scene: Scene, numberOfNodes: number) => HellixitboardElement[];
+export declare class FlowChartNavigator {
+    isExploring: boolean;
+    private sameLevelNodes;
+    private sameLevelIndex;
+    private direction;
+    private visitedNodes;
+    clear(): void;
+    exploreByDirection(element: HellixitboardElement, elementsMap: ElementsMap, direction: LinkDirection): HellixitboardElement["id"] | null;
+}
+export declare class FlowChartCreator {
+    isCreatingChart: boolean;
+    private numberOfNodes;
+    private direction;
+    pendingNodes: PendingHellixitboardElements | null;
+    createNodes(startNode: HellixitboardFlowchartNodeElement, appState: AppState, direction: LinkDirection, scene: Scene): void;
+    clear(): void;
+}
+export declare const isNodeInFlowchart: (element: HellixitboardFlowchartNodeElement, elementsMap: ElementsMap) => boolean;
+export {};

package/dist/types/element/src/fractionalIndex.d.ts

@@ -0,0 +1,57 @@
+import type { ElementsMap, HellixitboardElement, OrderedHellixitboardElement, SceneElementsMap } from "./types";
+export declare class InvalidFractionalIndexError extends Error {
+    code: "ELEMENT_HAS_INVALID_INDEX";
+}
+/**
+ * Envisioned relation between array order and fractional indices:
+ *
+ * 1) Array (or array-like ordered data structure) should be used as a cache of elements order, hiding the internal fractional indices implementation.
+ * - it's undesirable to perform reorder for each related operation, therefore it's necessary to cache the order defined by fractional indices into an ordered data structure
+ * - it's easy enough to define the order of the elements from the outside (boundaries), without worrying about the underlying structure of fractional indices (especially for the host apps)
+ * - it's necessary to always keep the array support for backwards compatibility (restore) - old scenes, old libraries, supporting multiple hellixitboard versions etc.
+ * - it's necessary to always keep the fractional indices in sync with the array order
+ * - elements with invalid indices should be detected and synced, without altering the already valid indices
+ *
+ * 2) Fractional indices should be used to reorder the elements, whenever the cached order is expected to be invalidated.
+ * - as the fractional indices are encoded as part of the elements, it opens up possibilities for incremental-like APIs
+ * - re-order based on fractional indices should be part of (multiplayer) operations such as reconciliation & undo/redo
+ * - technically all the z-index actions could perform also re-order based on fractional indices,but in current state it would not bring much benefits,
+ *   as it's faster & more efficient to perform re-order based on array manipulation and later synchronisation of moved indices with the array order
+ */
+/**
+ * Ensure that all elements have valid fractional indices.
+ *
+ * @throws `InvalidFractionalIndexError` if invalid index is detected.
+ */
+export declare const validateFractionalIndices: (elements: readonly HellixitboardElement[], { shouldThrow, includeBoundTextValidation, ignoreLogs, reconciliationContext, }: {
+    shouldThrow: boolean;
+    includeBoundTextValidation: boolean;
+    ignoreLogs?: true;
+    reconciliationContext?: {
+        localElements: ReadonlyArray<HellixitboardElement>;
+        remoteElements: ReadonlyArray<HellixitboardElement>;
+    };
+}) => void;
+/**
+ * Order the elements based on the fractional indices.
+ * - when fractional indices are identical, break the tie based on the element id
+ * - when there is no fractional index in one of the elements, respect the order of the array
+ */
+export declare const orderByFractionalIndex: (elements: OrderedHellixitboardElement[]) => OrderedHellixitboardElement[];
+/**
+ * Synchronizes invalid fractional indices of moved elements with the array order by mutating passed elements.
+ * If the synchronization fails or the result is invalid, it fallbacks to `syncInvalidIndices`.
+ */
+export declare const syncMovedIndices: (elements: readonly HellixitboardElement[], movedElements: ElementsMap) => OrderedHellixitboardElement[];
+/**
+ * Synchronizes all invalid fractional indices within the array order by mutating elements in the passed array.
+ *
+ * WARN: in edge cases it could modify the elements which were not moved, as it's impossible to guess the actually moved elements from the elements array itself.
+ */
+export declare const syncInvalidIndices: (elements: readonly HellixitboardElement[]) => OrderedHellixitboardElement[];
+/**
+ * Synchronizes all invalid fractional indices within the array order by creating new instances of elements with corrected indices.
+ *
+ * WARN: in edge cases it could modify the elements which were not moved, as it's impossible to guess the actually moved elements from the elements array itself.
+ */
+export declare const syncInvalidIndicesImmutable: (elements: readonly HellixitboardElement[]) => SceneElementsMap | undefined;

package/dist/types/element/src/frame.d.ts

@@ -0,0 +1,74 @@
+import type { AppClassProperties, AppState, StaticCanvasAppState } from "@hellixit/hellixitboard/types";
+import type { ReadonlySetLike } from "@excalidraw/common/utility-types";
+import type { HellixitboardElementsIncludingDeleted } from "./Scene";
+import type { ElementsMap, ElementsMapOrArray, HellixitboardElement, HellixitboardFrameLikeElement, NonDeleted, NonDeletedHellixitboardElement } from "./types";
+export declare const bindElementsToFramesAfterDuplication: (nextElements: readonly HellixitboardElement[], origElements: readonly HellixitboardElement[], origIdToDuplicateId: Map<HellixitboardElement["id"], HellixitboardElement["id"]>) => void;
+export declare function isElementIntersectingFrame(element: HellixitboardElement, frame: HellixitboardFrameLikeElement, elementsMap: ElementsMap): boolean;
+export declare const getElementsCompletelyInFrame: (elements: readonly HellixitboardElement[], frame: HellixitboardFrameLikeElement, elementsMap: ElementsMap) => HellixitboardElement[];
+export declare const isElementContainingFrame: (element: HellixitboardElement, frame: HellixitboardFrameLikeElement, elementsMap: ElementsMap) => boolean;
+export declare const getElementsIntersectingFrame: (elements: readonly HellixitboardElement[], frame: HellixitboardFrameLikeElement) => HellixitboardElement[];
+export declare const elementsAreInFrameBounds: (elements: readonly HellixitboardElement[], frame: HellixitboardFrameLikeElement, elementsMap: ElementsMap) => boolean;
+export declare const elementOverlapsWithFrame: (element: HellixitboardElement, frame: HellixitboardFrameLikeElement, elementsMap: ElementsMap) => boolean;
+export declare const isCursorInFrame: (cursorCoords: {
+    x: number;
+    y: number;
+}, frame: NonDeleted<HellixitboardFrameLikeElement>, elementsMap: ElementsMap) => boolean;
+export declare const groupsAreAtLeastIntersectingTheFrame: (elements: readonly NonDeletedHellixitboardElement[], groupIds: readonly string[], frame: HellixitboardFrameLikeElement) => boolean;
+export declare const groupsAreCompletelyOutOfFrame: (elements: readonly NonDeletedHellixitboardElement[], groupIds: readonly string[], frame: HellixitboardFrameLikeElement) => boolean;
+/**
+ * Returns a map of frameId to frame elements. Includes empty frames.
+ */
+export declare const groupByFrameLikes: (elements: readonly HellixitboardElement[]) => Map<string, HellixitboardElement[]>;
+export declare const getFrameChildren: (allElements: ElementsMapOrArray, frameId: string) => HellixitboardElement[];
+export declare const getFrameLikeElements: (allElements: HellixitboardElementsIncludingDeleted) => HellixitboardFrameLikeElement[];
+/**
+ * Returns HellixitboardFrameElements and non-frame-children elements.
+ *
+ * Considers children as root elements if they point to a frame parent
+ * non-existing in the elements set.
+ *
+ * Considers non-frame bound elements (container or arrow labels) as root.
+ */
+export declare const getRootElements: (allElements: HellixitboardElementsIncludingDeleted) => HellixitboardElement[];
+export declare const getElementsInResizingFrame: (allElements: HellixitboardElementsIncludingDeleted, frame: HellixitboardFrameLikeElement, appState: AppState, elementsMap: ElementsMap) => HellixitboardElement[];
+export declare const getElementsInNewFrame: (elements: HellixitboardElementsIncludingDeleted, frame: HellixitboardFrameLikeElement, elementsMap: ElementsMap) => (import("./types").HellixitboardLinearElement | import("./types").HellixitboardSelectionElement | import("./types").HellixitboardRectangleElement | import("./types").HellixitboardDiamondElement | import("./types").HellixitboardEllipseElement | import("./types").HellixitboardEmbeddableElement | import("./types").HellixitboardIframeElement | import("./types").HellixitboardImageElement | import("./types").HellixitboardFrameElement | import("./types").HellixitboardMagicFrameElement | import("./types").HellixitboardTextElement | import("./types").HellixitboardFreeDrawElement)[];
+export declare const omitPartialGroups: (elements: HellixitboardElement[], frame: HellixitboardFrameLikeElement, allElementsMap: ElementsMap) => (import("./types").HellixitboardLinearElement | import("./types").HellixitboardSelectionElement | import("./types").HellixitboardRectangleElement | import("./types").HellixitboardDiamondElement | import("./types").HellixitboardEllipseElement | import("./types").HellixitboardEmbeddableElement | import("./types").HellixitboardIframeElement | import("./types").HellixitboardImageElement | import("./types").HellixitboardFrameElement | import("./types").HellixitboardMagicFrameElement | import("./types").HellixitboardTextElement | import("./types").HellixitboardFreeDrawElement)[];
+export declare const getContainingFrame: (element: HellixitboardElement, elementsMap: ElementsMap) => HellixitboardFrameLikeElement | null;
+/** */
+export declare const filterElementsEligibleAsFrameChildren: (elements: readonly HellixitboardElement[], frame: HellixitboardFrameLikeElement) => HellixitboardElement[];
+/**
+ * Retains (or repairs for target frame) the ordering invriant where children
+ * elements come right before the parent frame:
+ * [el, el, child, child, frame, el]
+ *
+ * @returns mutated allElements (same data structure)
+ */
+export declare const addElementsToFrame: <T extends ElementsMapOrArray>(allElements: T, elementsToAdd: NonDeletedHellixitboardElement[], frame: HellixitboardFrameLikeElement, appState: AppState) => T;
+export declare const removeElementsFromFrame: (elementsToRemove: ReadonlySetLike<NonDeletedHellixitboardElement>, elementsMap: ElementsMap) => void;
+export declare const removeAllElementsFromFrame: <T extends HellixitboardElement>(allElements: readonly T[], frame: HellixitboardFrameLikeElement) => readonly T[];
+export declare const replaceAllElementsInFrame: <T extends HellixitboardElement>(allElements: readonly T[], nextElementsInFrame: HellixitboardElement[], frame: HellixitboardFrameLikeElement, app: AppClassProperties) => T[];
+/** does not mutate elements, but returns new ones */
+export declare const updateFrameMembershipOfSelectedElements: <T extends ElementsMapOrArray>(allElements: T, appState: AppState, app: AppClassProperties) => T;
+/**
+ * filters out elements that are inside groups that contain a frame element
+ * anywhere in the group tree
+ */
+export declare const omitGroupsContainingFrameLikes: (allElements: ElementsMapOrArray, 
+/** subset of elements you want to filter. Optional perf optimization so we
+ * don't have to filter all elements unnecessarily
+ */
+selectedElements?: readonly HellixitboardElement[]) => HellixitboardElement[];
+/**
+ * depending on the appState, return target frame, which is the frame the given element
+ * is going to be added to or remove from
+ */
+export declare const getTargetFrame: (element: HellixitboardElement, elementsMap: ElementsMap, appState: StaticCanvasAppState) => HellixitboardFrameLikeElement | null;
+export declare const isElementInFrame: (element: HellixitboardElement, allElementsMap: ElementsMap, appState: StaticCanvasAppState, opts?: {
+    targetFrame?: HellixitboardFrameLikeElement;
+    checkedGroups?: Map<string, boolean>;
+}) => boolean;
+export declare const shouldApplyFrameClip: (element: HellixitboardElement, frame: HellixitboardFrameLikeElement, appState: StaticCanvasAppState, elementsMap: ElementsMap, checkedGroups?: Map<string, boolean>) => boolean;
+export declare const getDefaultFrameName: (element: HellixitboardFrameLikeElement) => "Frame" | "AI Frame";
+export declare const getFrameLikeTitle: (element: HellixitboardFrameLikeElement) => string;
+export declare const getElementsOverlappingFrame: (elements: readonly HellixitboardElement[], frame: HellixitboardFrameLikeElement) => NonDeletedHellixitboardElement[];
+export declare const frameAndChildrenSelectedTogether: (selectedElements: readonly HellixitboardElement[]) => boolean;

package/dist/types/element/src/groups.d.ts

@@ -0,0 +1,34 @@
+import type { AppClassProperties, AppState, InteractiveCanvasAppState } from "@hellixit/hellixitboard/types";
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type { GroupId, HellixitboardElement, NonDeleted, NonDeletedHellixitboardElement, ElementsMapOrArray, ElementsMap } from "./types";
+export declare const selectGroup: (groupId: GroupId, appState: InteractiveCanvasAppState, elements: readonly NonDeleted<HellixitboardElement>[]) => Pick<InteractiveCanvasAppState, "selectedGroupIds" | "selectedElementIds" | "editingGroupId">;
+export declare const selectGroupsForSelectedElements: {
+    (appState: Pick<AppState, "selectedElementIds" | "editingGroupId">, elements: readonly NonDeletedHellixitboardElement[], prevAppState: InteractiveCanvasAppState, app: AppClassProperties | null): Mutable<Pick<InteractiveCanvasAppState, "selectedGroupIds" | "editingGroupId" | "selectedElementIds">>;
+    clearCache(): void;
+};
+/**
+ * If the element's group is selected, don't render an individual
+ * selection border around it.
+ */
+export declare const isSelectedViaGroup: (appState: InteractiveCanvasAppState, element: HellixitboardElement) => boolean;
+export declare const getSelectedGroupForElement: (appState: Pick<InteractiveCanvasAppState, "editingGroupId" | "selectedGroupIds">, element: HellixitboardElement) => string | undefined;
+export declare const getSelectedGroupIds: (appState: InteractiveCanvasAppState) => GroupId[];
+export declare const selectGroupsFromGivenElements: (elements: readonly NonDeleted<HellixitboardElement>[], appState: InteractiveCanvasAppState) => {
+    [groupId: string]: boolean;
+};
+export declare const editGroupForSelectedElement: (appState: AppState, element: NonDeleted<HellixitboardElement>) => AppState;
+export declare const isElementInGroup: (element: HellixitboardElement, groupId: string) => boolean;
+export declare const getElementsInGroup: (elements: ElementsMapOrArray, groupId: string) => HellixitboardElement[];
+export declare const getSelectedGroupIdForElement: (element: HellixitboardElement, selectedGroupIds: {
+    [groupId: string]: boolean;
+}) => string | undefined;
+export declare const addToGroup: (prevGroupIds: HellixitboardElement["groupIds"], newGroupId: GroupId, editingGroupId: AppState["editingGroupId"]) => string[];
+export declare const removeFromSelectedGroups: (groupIds: HellixitboardElement["groupIds"], selectedGroupIds: {
+    [groupId: string]: boolean;
+}) => string[];
+export declare const getMaximumGroups: (elements: HellixitboardElement[], elementsMap: ElementsMap) => HellixitboardElement[][];
+export declare const getNonDeletedGroupIds: (elements: ElementsMap) => Set<string>;
+export declare const elementsAreInSameGroup: (elements: readonly HellixitboardElement[]) => boolean;
+export declare const isInGroup: (element: NonDeletedHellixitboardElement) => boolean;
+export declare const getNewGroupIdsForDuplication: (groupIds: HellixitboardElement["groupIds"], editingGroupId: AppState["editingGroupId"], mapper: (groupId: GroupId) => GroupId) => string[];
+export declare const getSelectedElementsByGroup: (selectedElements: HellixitboardElement[], elementsMap: ElementsMap, appState: Readonly<AppState>) => HellixitboardElement[][];

package/dist/types/element/src/heading.d.ts

@@ -0,0 +1,16 @@
+import { type Bounds } from "@excalidraw/common";
+import type { LocalPoint, GlobalPoint, Vector } from "@excalidraw/math";
+import type { HellixitboardBindableElement } from "./types";
+export declare const HEADING_RIGHT: Heading;
+export declare const HEADING_DOWN: Heading;
+export declare const HEADING_LEFT: Heading;
+export declare const HEADING_UP: Heading;
+export type Heading = [1, 0] | [0, 1] | [-1, 0] | [0, -1];
+export declare const vectorToHeading: (vec: Vector) => Heading;
+export declare const headingForPoint: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => Heading;
+export declare const headingForPointIsHorizontal: <P extends GlobalPoint | LocalPoint>(p: P, o: P) => boolean;
+export declare const compareHeading: (a: Heading, b: Heading) => boolean;
+export declare const headingIsHorizontal: (a: Heading) => boolean;
+export declare const headingIsVertical: (a: Heading) => boolean;
+export declare const headingForPointFromElement: <Point extends GlobalPoint>(element: Readonly<HellixitboardBindableElement>, aabb: Readonly<Bounds>, p: Readonly<Point>) => Heading;
+export declare const flipHeading: (h: Heading) => Heading;

package/dist/types/element/src/image.d.ts

@@ -0,0 +1,22 @@
+import type { AppClassProperties, DataURL, BinaryFiles } from "@hellixit/hellixitboard/types";
+import type { HellixitboardElement, FileId, InitializedHellixitboardImageElement } from "./types";
+export declare const loadHTMLImageElement: (dataURL: DataURL) => Promise<HTMLImageElement>;
+/** NOTE: updates cache even if already populated with given image. Thus,
+ * you should filter out the images upstream if you want to optimize this. */
+export declare const updateImageCache: ({ fileIds, files, imageCache, }: {
+    fileIds: FileId[];
+    files: BinaryFiles;
+    imageCache: AppClassProperties["imageCache"];
+}) => Promise<{
+    imageCache: Map<FileId, {
+        image: HTMLImageElement | Promise<HTMLImageElement>;
+        mimeType: import("@excalidraw/common/utility-types").ValueOf<typeof import("@excalidraw/common").IMAGE_MIME_TYPES>;
+    }>;
+    /** includes errored files because they cache was updated nonetheless */
+    updatedFiles: Map<FileId, true>;
+    /** files that failed when creating HTMLImageElement */
+    erroredFiles: Map<FileId, true>;
+}>;
+export declare const getInitializedImageElements: (elements: readonly HellixitboardElement[]) => InitializedHellixitboardImageElement[];
+export declare const isHTMLSVGElement: (node: Node | null) => node is SVGElement;
+export declare const normalizeSVG: (SVGString: string) => string;

package/dist/types/element/src/index.d.ts

@@ -0,0 +1,59 @@
+import type { HellixitboardElement, NonDeletedHellixitboardElement, NonDeleted, ElementsMapOrArray } from "./types";
+/**
+ * @deprecated unsafe, use hashElementsVersion instead
+ */
+export declare const getSceneVersion: (elements: readonly HellixitboardElement[]) => number;
+/**
+ * Hashes elements' versionNonce (using djb2 algo). Order of elements matters.
+ */
+export declare const hashElementsVersion: (elements: ElementsMapOrArray) => number;
+export declare const hashString: (s: string) => number;
+export declare const getVisibleElements: (elements: readonly HellixitboardElement[]) => readonly NonDeletedHellixitboardElement[];
+export declare const getNonDeletedElements: <T extends HellixitboardElement>(elements: readonly T[]) => readonly NonDeleted<T>[];
+export declare const isNonDeletedElement: <T extends HellixitboardElement>(element: T) => element is NonDeleted<T>;
+export * from "./align";
+export * from "./binding";
+export * from "./bounds";
+export * from "./collision";
+export * from "./comparisons";
+export * from "./containerCache";
+export * from "./cropElement";
+export * from "./delta";
+export * from "./distance";
+export * from "./distribute";
+export * from "./dragElements";
+export * from "./duplicate";
+export * from "./elbowArrow";
+export * from "./elementLink";
+export * from "./embeddable";
+export * from "./flowchart";
+export * from "./arrows/focus";
+export * from "./fractionalIndex";
+export * from "./frame";
+export * from "./groups";
+export * from "./heading";
+export * from "./image";
+export * from "./linearElementEditor";
+export * from "./mutateElement";
+export * from "./newElement";
+export * from "./positionElementsOnGrid";
+export * from "./renderElement";
+export * from "./resizeElements";
+export * from "./resizeTest";
+export * from "./Scene";
+export * from "./selection";
+export * from "./shape";
+export * from "./showSelectedShapeActions";
+export * from "./sizeHelpers";
+export * from "./sortElements";
+export * from "./store";
+export * from "./textElement";
+export * from "./textMeasurements";
+export * from "./textWrapping";
+export * from "./transform";
+export * from "./transformHandles";
+export * from "./typeChecks";
+export * from "./utils";
+export * from "./zindex";
+export * from "./arrows/helpers";
+export * from "./arrowheads";

package/dist/types/element/src/linearElementEditor.d.ts

@@ -0,0 +1,118 @@
+import { type GlobalPoint, type LocalPoint } from "@excalidraw/math";
+import { type Store } from "@excalidraw/element";
+import type { AppState, PointerCoords, InteractiveCanvasAppState, AppClassProperties, NullableGridSize, Zoom } from "@hellixit/hellixitboard/types";
+import type { Bounds } from "@excalidraw/common";
+import type { Scene } from "./Scene";
+import type { NonDeleted, HellixitboardLinearElement, HellixitboardElement, HellixitboardTextElementWithContainer, ElementsMap, NonDeletedSceneElementsMap, FixedPointBinding, HellixitboardElbowArrowElement, PointsPositionUpdates } from "./types";
+export declare class LinearElementEditor {
+    readonly elementId: HellixitboardElement["id"] & {
+        _brand: "hellixitboardLinearElementId";
+    };
+    /** indices */
+    readonly selectedPointsIndices: readonly number[] | null;
+    readonly initialState: Readonly<{
+        prevSelectedPointsIndices: readonly number[] | null;
+        /** index */
+        lastClickedPoint: number;
+        origin: Readonly<GlobalPoint> | null;
+        segmentMidpoint: {
+            value: GlobalPoint | null;
+            index: number | null;
+            added: boolean;
+        };
+        arrowStartIsInside: boolean;
+        altFocusPoint: Readonly<GlobalPoint> | null;
+    }>;
+    /** whether you're dragging a point */
+    readonly isDragging: boolean;
+    readonly lastUncommittedPoint: LocalPoint | null;
+    readonly lastCommittedPoint: LocalPoint | null;
+    readonly pointerOffset: Readonly<{
+        x: number;
+        y: number;
+    }>;
+    readonly hoverPointIndex: number;
+    readonly segmentMidPointHoveredCoords: GlobalPoint | null;
+    readonly hoveredFocusPointBinding: "start" | "end" | null;
+    readonly draggedFocusPointBinding: "start" | "end" | null;
+    readonly elbowed: boolean;
+    readonly customLineAngle: number | null;
+    readonly isEditing: boolean;
+    readonly pointerDownState: never;
+    constructor(element: NonDeleted<HellixitboardLinearElement>, elementsMap: ElementsMap, isEditing?: boolean);
+    static POINT_HANDLE_SIZE: number;
+    /**
+     * @param id the `elementId` from the instance of this class (so that we can
+     *  statically guarantee this method returns an HellixitboardLinearElement)
+     */
+    static getElement<T extends HellixitboardLinearElement>(id: InstanceType<typeof LinearElementEditor>["elementId"], elementsMap: ElementsMap): T | null;
+    static handleBoxSelection(event: PointerEvent, appState: AppState, setState: React.Component<any, AppState>["setState"], elementsMap: NonDeletedSceneElementsMap): false | undefined;
+    static handlePointerMove(event: PointerEvent, app: AppClassProperties, scenePointerX: number, scenePointerY: number, linearElementEditor: LinearElementEditor): Pick<AppState, "suggestedBinding" | "selectedLinearElement"> | null;
+    static handlePointDragging(event: PointerEvent, app: AppClassProperties, scenePointerX: number, scenePointerY: number, linearElementEditor: LinearElementEditor): Pick<AppState, "suggestedBinding" | "selectedLinearElement"> | null;
+    static handlePointerUp(event: PointerEvent, editingLinearElement: LinearElementEditor, appState: AppState, scene: Scene): LinearElementEditor;
+    static getEditorMidPoints: (element: NonDeleted<HellixitboardLinearElement>, elementsMap: ElementsMap, appState: InteractiveCanvasAppState) => (GlobalPoint | null)[];
+    static getSegmentMidpointHitCoords: (linearElementEditor: LinearElementEditor, scenePointer: {
+        x: number;
+        y: number;
+    }, appState: AppState, elementsMap: ElementsMap) => GlobalPoint | null;
+    static isSegmentTooShort<P extends GlobalPoint | LocalPoint>(element: NonDeleted<HellixitboardLinearElement>, startPoint: P, endPoint: P, index: number, zoom: Zoom): boolean;
+    static getSegmentMidPoint(element: NonDeleted<HellixitboardLinearElement>, index: number): GlobalPoint;
+    static getSegmentMidPointIndex(linearElementEditor: LinearElementEditor, appState: AppState, midPoint: GlobalPoint, elementsMap: ElementsMap): number;
+    static handlePointerDown(event: React.PointerEvent<HTMLElement>, app: AppClassProperties, store: Store, scenePointer: {
+        x: number;
+        y: number;
+    }, linearElementEditor: LinearElementEditor, scene: Scene): {
+        didAddPoint: boolean;
+        hitElement: NonDeleted<HellixitboardElement> | null;
+        linearElementEditor: LinearElementEditor | null;
+    };
+    static arePointsEqual<Point extends LocalPoint | GlobalPoint>(point1: Point | null, point2: Point | null): boolean;
+    static handlePointerMoveInEditMode(event: React.PointerEvent<HTMLCanvasElement>, scenePointerX: number, scenePointerY: number, app: AppClassProperties): LinearElementEditor | null;
+    /** scene coords */
+    static getPointGlobalCoordinates(element: NonDeleted<HellixitboardLinearElement>, p: LocalPoint, elementsMap: ElementsMap): GlobalPoint;
+    /** scene coords */
+    static getPointsGlobalCoordinates(element: NonDeleted<HellixitboardLinearElement>, elementsMap: ElementsMap): GlobalPoint[];
+    static getPointAtIndexGlobalCoordinates(element: NonDeleted<HellixitboardLinearElement>, indexMaybeFromEnd: number, // -1 for last element
+    elementsMap: ElementsMap): GlobalPoint;
+    static pointFromAbsoluteCoords(element: NonDeleted<HellixitboardLinearElement>, absoluteCoords: GlobalPoint, elementsMap: ElementsMap): LocalPoint;
+    static getPointIndexUnderCursor(element: NonDeleted<HellixitboardLinearElement>, elementsMap: ElementsMap, zoom: AppState["zoom"], x: number, y: number): number;
+    static createPointAt(element: NonDeleted<HellixitboardLinearElement>, elementsMap: ElementsMap, scenePointerX: number, scenePointerY: number, gridSize: NullableGridSize): LocalPoint;
+    /**
+     * Normalizes line points so that the start point is at [0,0]. This is
+     * expected in various parts of the codebase.
+     *
+     * Also returns normalized x and y coords to account for the normalization
+     * of the points.
+     */
+    static getNormalizeElementPointsAndCoords(element: HellixitboardLinearElement): {
+        points: LocalPoint[];
+        x: number;
+        y: number;
+    };
+    static duplicateSelectedPoints(appState: AppState, scene: Scene): AppState;
+    static deletePoints(element: NonDeleted<HellixitboardLinearElement>, app: AppClassProperties, pointIndices: readonly number[]): void;
+    static addPoints(element: NonDeleted<HellixitboardLinearElement>, scene: Scene, addedPoints: LocalPoint[]): void;
+    static movePoints(element: NonDeleted<HellixitboardLinearElement>, scene: Scene, pointUpdates: PointsPositionUpdates, otherUpdates?: {
+        startBinding?: FixedPointBinding | null;
+        endBinding?: FixedPointBinding | null;
+        moveMidPointsWithElement?: boolean | null;
+    }, options?: {
+        isBindingEnabled?: boolean;
+        isMidpointSnappingEnabled?: boolean;
+    }): void;
+    static shouldAddMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, appState: AppState, elementsMap: ElementsMap): boolean;
+    static addMidpoint(linearElementEditor: LinearElementEditor, pointerCoords: PointerCoords, app: AppClassProperties, snapToGrid: boolean, scene: Scene): {
+        pointerDownState: LinearElementEditor["initialState"];
+        selectedPointsIndices: LinearElementEditor["selectedPointsIndices"];
+    } | undefined;
+    private static _updatePoints;
+    private static _getShiftLockedDelta;
+    static getBoundTextElementPosition: (element: HellixitboardLinearElement, boundTextElement: HellixitboardTextElementWithContainer, elementsMap: ElementsMap) => {
+        x: number;
+        y: number;
+    };
+    static getMinMaxXYWithBoundText: (element: HellixitboardLinearElement, elementsMap: ElementsMap, elementBounds: Bounds, boundTextElement: HellixitboardTextElementWithContainer) => [number, number, number, number, number, number];
+    static getElementAbsoluteCoords: (element: HellixitboardLinearElement, elementsMap: ElementsMap, includeBoundText?: boolean) => [number, number, number, number, number, number];
+    static moveFixedSegment(linearElement: LinearElementEditor, index: number, x: number, y: number, scene: Scene): Pick<LinearElementEditor, "segmentMidPointHoveredCoords" | "initialState">;
+    static deleteFixedSegment(element: HellixitboardElbowArrowElement, scene: Scene, index: number): void;
+}

package/dist/types/element/src/mutateElement.d.ts

@@ -0,0 +1,25 @@
+import type { Mutable } from "@excalidraw/common/utility-types";
+import type { ElementsMap, HellixitboardElement } from "./types";
+export type ElementUpdate<TElement extends HellixitboardElement> = Omit<Partial<TElement>, "id" | "updated">;
+/**
+ * This function tracks updates of text elements for the purposes for collaboration.
+ * The version is used to compare updates when more than one user is working in
+ * the same drawing.
+ *
+ * WARNING: this won't trigger the component to update, so if you need to trigger component update,
+ * use `scene.mutateElement` or `HellixitboardImperativeAPI.mutateElement` instead.
+ */
+export declare const mutateElement: <TElement extends Mutable<HellixitboardElement>>(element: TElement, elementsMap: ElementsMap, updates: ElementUpdate<TElement>, options?: {
+    isDragging?: boolean;
+    isBindingEnabled?: boolean;
+    isMidpointSnappingEnabled?: boolean;
+}) => TElement;
+export declare const newElementWith: <TElement extends HellixitboardElement>(element: TElement, updates: ElementUpdate<TElement>, 
+/** pass `true` to always regenerate */
+force?: boolean) => TElement;
+/**
+ * Mutates element, bumping `version`, `versionNonce`, and `updated`.
+ *
+ * NOTE: does not trigger re-render.
+ */
+export declare const bumpVersion: <T extends Mutable<HellixitboardElement>>(element: T, version?: HellixitboardElement["version"]) => T;

package/dist/types/element/src/newElement.d.ts

@@ -0,0 +1,62 @@
+import type { MarkOptional } from "@excalidraw/common/utility-types";
+import type { HellixitboardImageElement, HellixitboardTextElement, HellixitboardLinearElement, HellixitboardGenericElement, NonDeleted, TextAlign, VerticalAlign, Arrowhead, HellixitboardFreeDrawElement, FontFamilyValues, HellixitboardTextContainer, HellixitboardFrameElement, HellixitboardEmbeddableElement, HellixitboardMagicFrameElement, HellixitboardIframeElement, ElementsMap, HellixitboardArrowElement, HellixitboardElbowArrowElement, HellixitboardLineElement } from "./types";
+export type ElementConstructorOpts = MarkOptional<Omit<HellixitboardGenericElement, "id" | "type" | "isDeleted" | "updated">, "width" | "height" | "angle" | "groupIds" | "frameId" | "index" | "boundElements" | "seed" | "version" | "versionNonce" | "link" | "strokeStyle" | "fillStyle" | "strokeColor" | "backgroundColor" | "roughness" | "strokeWidth" | "roundness" | "locked" | "opacity" | "customData">;
+export declare const newElement: (opts: {
+    type: HellixitboardGenericElement["type"];
+} & ElementConstructorOpts) => NonDeleted<HellixitboardGenericElement>;
+export declare const newEmbeddableElement: (opts: {
+    type: "embeddable";
+} & ElementConstructorOpts) => NonDeleted<HellixitboardEmbeddableElement>;
+export declare const newIframeElement: (opts: {
+    type: "iframe";
+} & ElementConstructorOpts) => NonDeleted<HellixitboardIframeElement>;
+export declare const newFrameElement: (opts: {
+    name?: string;
+} & ElementConstructorOpts) => NonDeleted<HellixitboardFrameElement>;
+export declare const newMagicFrameElement: (opts: {
+    name?: string;
+} & ElementConstructorOpts) => NonDeleted<HellixitboardMagicFrameElement>;
+export declare const newTextElement: (opts: {
+    text: string;
+    originalText?: string;
+    fontSize?: number;
+    fontFamily?: FontFamilyValues;
+    textAlign?: TextAlign;
+    verticalAlign?: VerticalAlign;
+    containerId?: HellixitboardTextContainer["id"] | null;
+    lineHeight?: HellixitboardTextElement["lineHeight"];
+    autoResize?: HellixitboardTextElement["autoResize"];
+} & ElementConstructorOpts) => NonDeleted<HellixitboardTextElement>;
+export declare const refreshTextDimensions: (textElement: HellixitboardTextElement, container: HellixitboardTextContainer | null, elementsMap: ElementsMap, text?: string) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text: string;
+} | undefined;
+export declare const newFreeDrawElement: (opts: {
+    type: "freedraw";
+    points?: HellixitboardFreeDrawElement["points"];
+    simulatePressure: boolean;
+    pressures?: HellixitboardFreeDrawElement["pressures"];
+} & ElementConstructorOpts) => NonDeleted<HellixitboardFreeDrawElement>;
+export declare const newLinearElement: (opts: {
+    type: HellixitboardLinearElement["type"];
+    points?: HellixitboardLinearElement["points"];
+    polygon?: HellixitboardLineElement["polygon"];
+} & ElementConstructorOpts) => NonDeleted<HellixitboardLinearElement>;
+export declare const newArrowElement: <T extends boolean>(opts: {
+    type: HellixitboardArrowElement["type"];
+    startArrowhead?: Arrowhead | null;
+    endArrowhead?: Arrowhead | null;
+    points?: HellixitboardArrowElement["points"];
+    elbowed?: T;
+    fixedSegments?: HellixitboardElbowArrowElement["fixedSegments"] | null;
+} & ElementConstructorOpts) => T extends true ? NonDeleted<HellixitboardElbowArrowElement> : NonDeleted<HellixitboardArrowElement>;
+export declare const newImageElement: (opts: {
+    type: HellixitboardImageElement["type"];
+    status?: HellixitboardImageElement["status"];
+    fileId?: HellixitboardImageElement["fileId"];
+    scale?: HellixitboardImageElement["scale"];
+    crop?: HellixitboardImageElement["crop"];
+} & ElementConstructorOpts) => NonDeleted<HellixitboardImageElement>;

package/dist/types/element/src/positionElementsOnGrid.d.ts

@@ -0,0 +1,2 @@
+import type { HellixitboardElement } from "./types";
+export declare const positionElementsOnGrid: <TElement extends HellixitboardElement>(elements: TElement[] | TElement[][], centerX: number, centerY: number, padding?: number) => TElement[];