ducjs 1.0.0

package/dist/utils/elements/index.js

@@ -0,0 +1,215 @@
+export * from "./newElement";
+export * from "./freedrawElement";
+export * from "./linearElement";
+export * from "./textElement";
+export * from "./frameElement";
+export * from "./viewportElement";
+import { LINE_SPACING_TYPE, TABLE_CELL_ALIGNMENT, TABLE_FLOW_DIRECTION } from "ducjs/flatbuffers/duc";
+import { isFreeDrawElement, isLinearElement } from "ducjs/types/elements/typeChecks";
+import { getUpdatedTimestamp } from "ducjs/utils";
+import { DEFAULT_ELEMENT_PROPS, DEFAULT_FONT_FAMILY, DEFAULT_FONT_SIZE, DEFAULT_TEXT_ALIGN, DEFAULT_VERTICAL_ALIGN, FONT_FAMILY } from "ducjs/utils/constants";
+import { randomInteger } from "ducjs/utils/math/random";
+import { getPrecisionValueFromRaw } from "ducjs/technical/scopes";
+/**
+ * Returns a default DucTextStyle object for the given scope.
+ */
+export function getDefaultTextStyle(currentScope) {
+    return {
+        roundness: DEFAULT_ELEMENT_PROPS.roundness,
+        blending: undefined,
+        strokeColor: undefined,
+        backgroundColor: undefined,
+        background: [DEFAULT_ELEMENT_PROPS.background],
+        stroke: [DEFAULT_ELEMENT_PROPS.stroke],
+        opacity: DEFAULT_ELEMENT_PROPS.opacity,
+        isLtr: true,
+        fontFamily: DEFAULT_FONT_FAMILY,
+        bigFontFamily: "sans-serif",
+        textAlign: DEFAULT_TEXT_ALIGN,
+        verticalAlign: DEFAULT_VERTICAL_ALIGN,
+        lineHeight: 1.2,
+        lineSpacing: { type: LINE_SPACING_TYPE.MULTIPLE, value: 1.2 },
+        obliqueAngle: 0,
+        fontSize: getPrecisionValueFromRaw(DEFAULT_FONT_SIZE, currentScope, currentScope),
+        paperTextHeight: undefined,
+        widthFactor: 1,
+        isUpsideDown: false,
+        isBackwards: false,
+    };
+}
+/**
+ * Mutates element, bumping `version`, `versionNonce`, and `updated`.
+ *
+ * NOTE: does not trigger re-render.
+ */
+export const bumpVersion = (element, version) => {
+    element.version = (version !== null && version !== void 0 ? version : element.version) + 1;
+    element.versionNonce = randomInteger();
+    element.updated = getUpdatedTimestamp();
+    return element;
+};
+export const getDefaultStackProperties = () => {
+    return {
+        label: "",
+        description: null,
+        isCollapsed: false,
+        locked: false,
+        isVisible: true,
+        isPlot: true,
+        opacity: 1,
+        labelingColor: "transparent",
+    };
+};
+/**
+ * Returns the data structures for a default table.
+ * This does not include base element properties like x, y, width, etc.,
+ * which are added during element creation.
+ */
+export const getDefaultTableData = (currentScope) => {
+    // Default structure
+    const columnCount = 3;
+    const headerRowCount = 1;
+    const dataRowCount = 3; // header + 3 data rows
+    const totalRows = headerRowCount + dataRowCount;
+    const columnIds = Array.from({ length: columnCount }, (_, i) => `col${i + 1}`);
+    const rowIds = Array.from({ length: totalRows }, (_, i) => `row${i + 1}`);
+    // Spacing and sizing
+    const hMargin = getPrecisionValueFromRaw(8, currentScope, currentScope);
+    const vMargin = getPrecisionValueFromRaw(6, currentScope, currentScope);
+    const defaultFontSize = getPrecisionValueFromRaw(DEFAULT_FONT_SIZE, currentScope, currentScope);
+    // Slightly taller header row for visual hierarchy
+    const dataRowHeight = (defaultFontSize.value * 1.2) + (vMargin.value * 2);
+    const headerRowHeight = (defaultFontSize.value * 1.4) + (vMargin.value * 2);
+    // A practical starting column width
+    const defaultColumnWidth = getPrecisionValueFromRaw(140, currentScope, currentScope);
+    // Base/default styling for cells
+    const baseCellStyle = Object.assign(Object.assign({}, DEFAULT_ELEMENT_PROPS), { background: [DEFAULT_ELEMENT_PROPS.background], stroke: [DEFAULT_ELEMENT_PROPS.stroke], textStyle: {
+            isLtr: true,
+            fontFamily: FONT_FAMILY.Virgil,
+            bigFontFamily: "sans-serif",
+            textAlign: DEFAULT_TEXT_ALIGN,
+            verticalAlign: DEFAULT_VERTICAL_ALIGN,
+            lineHeight: 1.2,
+            lineSpacing: { type: LINE_SPACING_TYPE.MULTIPLE, value: 1.2 },
+            obliqueAngle: 0,
+            fontSize: defaultFontSize,
+            paperTextHeight: undefined,
+            widthFactor: 1,
+            isUpsideDown: false,
+            isBackwards: false,
+            roundness: DEFAULT_ELEMENT_PROPS.roundness,
+            background: [DEFAULT_ELEMENT_PROPS.background],
+            stroke: [DEFAULT_ELEMENT_PROPS.stroke],
+            opacity: DEFAULT_ELEMENT_PROPS.opacity,
+        }, margins: {
+            top: vMargin,
+            right: hMargin,
+            bottom: vMargin,
+            left: hMargin,
+        }, 
+        // Left + middle is a great general-purpose default for tables
+        alignment: TABLE_CELL_ALIGNMENT.MIDDLE_LEFT });
+    // Create default columns
+    const columns = Object.fromEntries(columnIds.map((id) => [id, { id, width: defaultColumnWidth }]));
+    // Create default rows (taller header row)
+    const rows = Object.fromEntries(rowIds.map((id, idx) => [
+        id,
+        {
+            id,
+            height: idx < headerRowCount
+                ? getPrecisionValueFromRaw(headerRowHeight, currentScope, currentScope)
+                : getPrecisionValueFromRaw(dataRowHeight, currentScope, currentScope)
+        },
+    ]));
+    // Create default cells
+    const cells = Object.create(null);
+    // Friendly header labels via Markdown (bold)
+    const headerLabels = ["Column A", "Column B", "Column C"];
+    rowIds.forEach((rowId, rIdx) => {
+        columnIds.forEach((colId, cIdx) => {
+            var _a;
+            const cellId = `${rowId}:${colId}`;
+            const isHeaderRow = rIdx < headerRowCount;
+            cells[cellId] = {
+                rowId,
+                columnId: colId,
+                data: isHeaderRow ? `**${(_a = headerLabels[cIdx]) !== null && _a !== void 0 ? _a : `Column ${cIdx + 1}`}**` : "",
+                locked: false,
+            };
+        });
+    });
+    return {
+        // Data Structure
+        columnOrder: columnIds,
+        rowOrder: rowIds,
+        columns,
+        rows,
+        cells,
+        // Style & Behavior
+        flowDirection: TABLE_FLOW_DIRECTION.DOWN,
+        headerRowStyle: baseCellStyle,
+        dataRowStyle: baseCellStyle,
+        dataColumnStyle: baseCellStyle,
+        headerRowCount,
+        // Let rows grow to fit content; keep columns fixed unless user opts in
+        autoSize: { columns: false, rows: true },
+    };
+};
+export const getBaseElementProps = (element) => {
+    return {
+        x: element.x,
+        y: element.y,
+        scope: element.scope,
+        label: element.label,
+        isVisible: element.isVisible,
+        isPlot: element.isPlot,
+        isAnnotative: element.isAnnotative,
+        layerId: element.layerId,
+        regionIds: element.regionIds,
+        roundness: element.roundness,
+        blending: element.blending,
+        background: element.background,
+        stroke: element.stroke,
+        opacity: element.opacity,
+        width: element.width,
+        height: element.height,
+        angle: element.angle,
+        groupIds: element.groupIds,
+        frameId: element.frameId,
+        boundElements: element.boundElements,
+        link: element.link,
+        locked: element.locked,
+        customData: element.customData,
+        description: element.description,
+        zIndex: element.zIndex,
+    };
+};
+export function convertPointToTuple(point) {
+    return [point.x, point.y];
+}
+// Helper function to migrate legacy tuple points to new Point objects
+export const migratePoints = (points) => {
+    return points.map(point => {
+        if (Array.isArray(point)) {
+            const [x, y] = point;
+            return { x, y };
+        }
+        return point; // Assume already migrated
+    });
+};
+export const getNonDeletedElements = (elements) => elements.filter((element) => !element.isDeleted);
+export const isInvisiblySmallElement = (element) => {
+    if (isLinearElement(element) || isFreeDrawElement(element)) {
+        return element.points.length < 2;
+    }
+    return element.width.scoped === 0 && element.height.scoped === 0;
+};
+/**
+ * Sorts a list of DucElements by their z-index (lowest first).
+ *
+ * @param elements The list of elements to sort.
+ * @returns A new array with elements sorted by z-index.
+ */
+export const getElementsSortedByZIndex = (elements) => {
+    return [...elements].sort((a, b) => a.zIndex - b.zIndex);
+};

package/dist/utils/elements/linearElement.d.ts

@@ -0,0 +1,53 @@
+import { HANDLE_TYPE } from "ducjs/flatbuffers/duc";
+import type { PrecisionValue, RawValue, Scope } from "ducjs/types";
+import type { DucLine, DucLinearElement, DucLinearLikeElement, DucPoint, DucTextElementWithContainer, ElementsMap, NonDeleted } from "ducjs/types/elements";
+import { Bounds, GeometricPoint } from "ducjs/types/geometryTypes";
+import type { ValueOf } from "ducjs/types/utility-types";
+import { ElementAbsoluteCoords } from "ducjs/utils/bounds";
+export type HandleType = ValueOf<typeof HANDLE_TYPE> | null;
+export type HandleInfo = {
+    pointIndex: number;
+    handleType: HandleInfo;
+    lineIndex: number;
+    handle: DucPoint;
+};
+/**
+ * Merges overlapping points using the line-based system
+ * Returns updated points and lines arrays
+ */
+export declare const mergeOverlappingPoints: (points: DucPoint[], lines: DucLine[], threshold?: RawValue) => {
+    points: DucPoint[];
+    lines: DucLine[];
+};
+/**
+ * Normalizes line points so that the start point is at [0,0]. This is
+ * expected in various parts of the codebase. Also returns new x/y to account
+ * for the potential normalization.
+ */
+export declare const getNormalizedPoints: (element: DucLinearElement | {
+    points: DucPoint[];
+    lines: DucLine[];
+    x: PrecisionValue;
+    y: PrecisionValue;
+    scope: Scope;
+}, currentScope: Scope) => {
+    points: DucPoint[];
+    lines: DucLine[];
+    x: PrecisionValue;
+    y: PrecisionValue;
+};
+/** scene coords */
+export declare const getPointsGlobalCoordinates: (element: DucLinearLikeElement, elementsMap: ElementsMap, currentScope: Scope) => DucPoint[];
+/** scene coords */
+export declare const getPointGlobalCoordinates: (element: DucLinearLikeElement, point: GeometricPoint, elementsMap: ElementsMap, currentScope: Scope) => GeometricPoint;
+export declare const getBoundTextElementPosition: (element: DucLinearLikeElement, boundTextElement: DucTextElementWithContainer, elementsMap: ElementsMap, currentScope: Scope) => GeometricPoint | null;
+export declare const getLinearElementAbsoluteCoords: (element: DucLinearElement, elementsMap: ElementsMap, includeBoundText: boolean | undefined, currentScope: Scope, returnUnrotatedBoundsOnly?: boolean) => ElementAbsoluteCoords;
+export declare const getMinMaxXYWithBoundText: (element: DucLinearElement, elementsMap: ElementsMap, elementBounds: Bounds, boundTextElement: DucTextElementWithContainer, currentScope: Scope) => ElementAbsoluteCoords;
+export declare const getSegmentMidPoint: (element: NonDeleted<DucLinearLikeElement>, startPoint: GeometricPoint, endPoint: GeometricPoint, endPointIndex: number, elementsMap: ElementsMap, currentScope: Scope) => GeometricPoint;
+/**
+ * Validates if the given line indices form a closed path in the element
+ * @param element The linear element containing the points and lines
+ * @param lineIndices Array of line indices to check
+ * @returns true if the line indices form a valid closed path, false otherwise
+ */
+export declare const validateClosedPath: (element: NonDeleted<DucLinearElement>, lineIndices: number[]) => boolean;