ducjs 1.0.0

package/dist/types/elements/index.js

@@ -0,0 +1 @@
+export * from "./typeChecks";

package/dist/types/elements/typeChecks.d.ts

@@ -0,0 +1,40 @@
+import type { ElementOrToolType } from "ducjs/types";
+import type { MarkNonNullable } from "ducjs/types/utility-types";
+import { Bounds, LineSegment, TuplePoint } from "ducjs/types/geometryTypes";
+import type { DucArrowElement, DucBindableElement, DucElbowArrowElement, DucElement, DucElementType, DucEmbeddableElement, DucFlowchartNodeElement, DucFrameElement, DucFrameLikeElement, DucFreeDrawElement, DucImageElement, DucLinearElement, DucTableElement, DucPointBinding, DucTextContainer, DucTextElement, DucTextElementWithContainer, FixedPointBinding, InitializedDucImageElement, DucNonSelectionElement, DucEllipseElement, DucPolygonElement, DucBlockInstanceElement, NonDeleted, DucIframeLikeElement } from "ducjs/types/elements";
+export declare const isInitializedImageElement: (element: DucElement | null) => element is InitializedDucImageElement;
+export declare const isImageElement: (element: DucElement | null) => element is DucImageElement;
+export declare const isEmbeddableElement: (element: DucElement | null | undefined) => element is DucEmbeddableElement;
+export declare const isTableElement: (element: DucElement | null) => element is DucTableElement;
+export declare const isIframeLikeElement: (element: DucElement | null) => element is DucIframeLikeElement;
+export declare const isTextElement: (element: DucElement | null) => element is DucTextElement;
+export declare const isFrameElement: (element: DucElement | null) => element is DucFrameElement;
+export declare const isFrameLikeElement: (element: DucElement | null) => element is DucFrameLikeElement;
+export declare const isFreeDrawElement: (element?: DucElement | null) => element is DucFreeDrawElement;
+export declare const isEllipseElement: (element?: DucElement | null) => element is DucEllipseElement;
+export declare const isPolygonElement: (element?: DucElement | null) => element is DucPolygonElement;
+export declare const isFreeDrawElementType: (elementType: DucElementType) => boolean;
+export declare const isLinearElement: (element?: DucElement | null) => element is DucLinearElement;
+export declare const isLinearElementType: (elementType: ElementOrToolType) => boolean;
+export declare const isFlowchartNodeElement: (element: DucElement) => element is DucFlowchartNodeElement;
+export declare const isShapeToLinearElementPossible: (element: DucElement) => element is DucNonSelectionElement;
+export declare const isArrowElement: (element?: DucElement | null) => element is DucArrowElement;
+export declare const isElbowArrow: (element?: DucElement) => element is DucElbowArrowElement;
+export declare const isBindingElement: (element?: DucElement | null, includeLocked?: boolean) => element is DucLinearElement;
+export declare const isBindingElementType: (elementType: ElementOrToolType) => boolean;
+export declare const isBindableElement: (element: DucElement | null | undefined, includeLocked?: boolean) => element is DucBindableElement;
+export declare const isRectanguloidElement: (element?: DucElement | null) => element is DucBindableElement;
+export declare const isBlockInstanceElement: (element?: DucElement | null) => element is DucBlockInstanceElement;
+export declare const isRectangularElement: (element?: DucElement | null) => element is DucBindableElement;
+export declare const isTextBindableContainer: (element: DucElement | null, includeLocked?: boolean) => element is DucTextContainer;
+export declare const isDucElement: (element: any) => element is DucElement;
+export declare const hasBoundTextElement: (element: DucElement | null) => element is MarkNonNullable<DucBindableElement, "boundElements">;
+export declare const isBoundToContainer: (element: DucElement | null) => element is DucTextElementWithContainer;
+export declare const isUsingAdaptiveRadius: (type: string) => type is "embeddable" | "image" | "rectangle" | "table";
+export declare const isUsingProportionalRadius: (type: string) => type is "line" | "arrow" | "diamond";
+export declare const isPoint: (point: unknown) => point is TuplePoint;
+export declare const isBounds: (box: unknown) => box is Bounds;
+export declare const isLineSegment: (segment: unknown) => segment is LineSegment;
+export declare const isFixedPointBinding: (binding: DucPointBinding) => binding is FixedPointBinding;
+export declare const isTable: (element: DucElement | null) => element is DucTableElement;
+export declare const isNonDeletedElement: <T extends DucElement>(element: T) => element is NonDeleted<T>;

package/dist/types/elements/typeChecks.js

@@ -0,0 +1,188 @@
+import { assertNever } from "ducjs/utils";
+export const isInitializedImageElement = (element) => {
+    return !!element && element.type === "image" && !!element.fileId;
+};
+export const isImageElement = (element) => {
+    return !!element && element.type === "image";
+};
+export const isEmbeddableElement = (element) => {
+    return !!element && element.type === "embeddable";
+};
+export const isTableElement = (element) => {
+    return !!element && element.type === "table";
+};
+export const isIframeLikeElement = (element) => {
+    return (!!element && (element.type === "embeddable" ||
+        element.type === "table" ||
+        element.type === "doc"));
+};
+export const isTextElement = (element) => {
+    return element != null && element.type === "text";
+};
+export const isFrameElement = (element) => {
+    return element != null && element.type === "frame";
+};
+export const isFrameLikeElement = (element) => {
+    return (element != null &&
+        (element.type === "frame"));
+};
+export const isFreeDrawElement = (element) => {
+    return element != null && isFreeDrawElementType(element.type);
+};
+export const isEllipseElement = (element) => {
+    return element != null && element.type === "ellipse";
+};
+export const isPolygonElement = (element) => {
+    return element != null && element.type === "polygon";
+};
+export const isFreeDrawElementType = (elementType) => {
+    return elementType === "freedraw";
+};
+export const isLinearElement = (element) => {
+    return element != null && isLinearElementType(element.type);
+};
+export const isLinearElementType = (elementType) => {
+    return (elementType === "arrow" || elementType === "line");
+};
+export const isFlowchartNodeElement = (element) => {
+    return (element.type === "rectangle" ||
+        element.type === "ellipse" ||
+        element.type === "polygon");
+};
+export const isShapeToLinearElementPossible = (element) => {
+    return (element.type === "rectangle" ||
+        element.type === "ellipse" ||
+        element.type === "polygon");
+};
+export const isArrowElement = (element) => {
+    return element != null && element.type === "arrow";
+};
+export const isElbowArrow = (element) => {
+    return isArrowElement(element) && element.elbowed;
+};
+export const isBindingElement = (element, includeLocked = true) => {
+    return (element != null &&
+        (!element.locked || includeLocked === true) &&
+        isBindingElementType(element.type));
+};
+export const isBindingElementType = (elementType) => {
+    return elementType === "arrow";
+};
+export const isBindableElement = (element, includeLocked = true) => {
+    return (element != null &&
+        (!element.locked || includeLocked === true) &&
+        (element.type === "rectangle" ||
+            element.type === "polygon" ||
+            element.type === "ellipse" ||
+            element.type === "image" ||
+            element.type === "embeddable" ||
+            element.type === "frame" ||
+            element.type === "line" ||
+            element.type === "arrow" ||
+            (element.type === "text" && !element.containerId)));
+};
+export const isRectanguloidElement = (element) => {
+    return (element != null &&
+        (element.type === "rectangle" ||
+            element.type === "image" ||
+            element.type === "embeddable" ||
+            element.type === "frame" ||
+            element.type === "table" ||
+            (element.type === "text" && !element.containerId)));
+};
+export const isBlockInstanceElement = (element) => {
+    return element != null && element.type === "blockinstance";
+};
+// TODO: Remove this when proper distance calculation is introduced
+// @see binding.ts:distanceToBindableElement()
+export const isRectangularElement = (element) => {
+    return (element != null &&
+        (element.type === "rectangle" ||
+            element.type === "image" ||
+            element.type === "text" ||
+            element.type === "embeddable" ||
+            element.type === "frame" ||
+            element.type === "table"));
+};
+export const isTextBindableContainer = (element, includeLocked = true) => {
+    return (element != null &&
+        (!element.locked || includeLocked === true) &&
+        (element.type === "rectangle" ||
+            element.type === "polygon" ||
+            element.type === "ellipse" ||
+            isArrowElement(element)));
+};
+export const isDucElement = (element) => {
+    const type = element === null || element === void 0 ? void 0 : element.type;
+    if (!type) {
+        return false;
+    }
+    switch (type) {
+        case "text":
+        case "polygon":
+        case "rectangle":
+        case "embeddable":
+        case "ellipse":
+        case "arrow":
+        case "freedraw":
+        case "line":
+        case "frame":
+        case "image":
+        case "table":
+        case "dimension":
+        case "leader":
+        case "doc":
+        case "blockinstance":
+        case "selection":
+        case "parametric":
+        case "featurecontrolframe":
+        case "viewport":
+        case "plot":
+        case "xray":
+        case "pdf":
+        case "mermaid": {
+            return true;
+        }
+        default: {
+            assertNever(type, null);
+            return false;
+        }
+    }
+};
+export const hasBoundTextElement = (element) => {
+    var _a;
+    return (isTextBindableContainer(element) &&
+        !!((_a = element.boundElements) === null || _a === void 0 ? void 0 : _a.some(({ type }) => type === "text")));
+};
+export const isBoundToContainer = (element) => {
+    return (element !== null &&
+        "containerId" in element &&
+        element.containerId !== null &&
+        isTextElement(element));
+};
+export const isUsingAdaptiveRadius = (type) => type === "rectangle" ||
+    type === "embeddable" ||
+    type === "image" ||
+    type === "table";
+export const isUsingProportionalRadius = (type) => type === "line" || type === "arrow" || type === "diamond";
+// TODO: Move this to @excalidraw/math
+export const isPoint = (point) => Array.isArray(point) && point.length === 2;
+// TODO: Move this to @excalidraw/math
+export const isBounds = (box) => Array.isArray(box) &&
+    box.length === 4 &&
+    typeof box[0] === "number" &&
+    typeof box[1] === "number" &&
+    typeof box[2] === "number" &&
+    typeof box[3] === "number";
+// TODO: Move this to @excalidraw/math
+export const isLineSegment = (segment) => Array.isArray(segment) &&
+    segment.length === 2 &&
+    isPoint(segment[0]) &&
+    isPoint(segment[0]);
+export const isFixedPointBinding = (binding) => {
+    return binding.fixedPoint != null;
+};
+export const isTable = (element) => {
+    return (element === null || element === void 0 ? void 0 : element.type) === "table";
+};
+export const isNonDeletedElement = (element) => !element.isDeleted;

package/dist/types/geometryTypes.d.ts

@@ -0,0 +1,90 @@
+import { AXIS } from "ducjs/flatbuffers/duc";
+import { ScopedValue, ValueOf } from "ducjs/types";
+/**
+ * Axis such as X, Y, Z
+ */
+export type Axis = ValueOf<typeof AXIS>;
+/**
+ * x and y position of top left corner, x and y position of bottom right corner
+ */
+export type Bounds = readonly [
+    minX: ScopedValue,
+    minY: ScopedValue,
+    maxX: ScopedValue,
+    maxY: ScopedValue
+];
+/**
+ * Scale factor is a multiplier to a given value
+ * @default 1
+ */
+export type ScaleFactor = number & {
+    __brand: "ScaleFactor";
+};
+/**
+ * Angle in Radian
+ * Ranges from 0 to 2π: 0 - 360°
+ */
+export type Radian = number & {
+    __brand: "Radian";
+};
+/**
+ * Percentage
+ * Ranges from 0 to 1: 0% - 100%
+ */
+export type Percentage = number & {
+    __brand: "Percentage";
+};
+export type GeometricPoint = {
+    x: number;
+    y: number;
+};
+export type GeometricVector = GeometricPoint;
+export type TuplePoint = [number, number];
+export type ElementsSegmentsMap = Map<string, GeometricPoint[]>;
+export type Line = [GeometricPoint, GeometricPoint];
+export type LineSegment = Line;
+export type Polyline = Line[];
+export type Curve = [GeometricPoint, GeometricPoint, GeometricPoint, GeometricPoint];
+export type Polycurve = Curve[];
+export type Polygon = GeometricPoint[];
+export type Ellipse = {
+    center: GeometricPoint;
+    angle: number;
+    halfWidth: number;
+    halfHeight: number;
+};
+export type GeometricShape = {
+    type: "line";
+    data: Line;
+} | {
+    type: "polygon";
+    data: Polygon;
+} | {
+    type: "curve";
+    data: Curve;
+} | {
+    type: "ellipse";
+    data: Ellipse;
+} | {
+    type: "polyline";
+    data: Polyline;
+} | {
+    type: "polycurve";
+    data: Polycurve;
+};
+/**
+ * Defines the possible headings using the new Point interface.
+ */
+export type Heading = {
+    x: 1;
+    y: 0;
+} | {
+    x: 0;
+    y: 1;
+} | {
+    x: -1;
+    y: 0;
+} | {
+    x: 0;
+    y: -1;
+};

package/dist/types/geometryTypes.js

@@ -0,0 +1 @@
+export {};