ofs-dxf-ts 1.0.0

package/dist/geometry/math.utils.js

@@ -0,0 +1,43 @@
+export function formatDistance(distance) {
+    const km = Math.floor(distance / 1000);
+    const meters = Math.floor(distance % 1000);
+    const metersStr = meters.toString().padStart(3, '0');
+    return `KM ${km}+${metersStr}`;
+}
+export function calculateDistance(p1, p2) {
+    return Math.hypot(p2[0] - p1[0], p2[1] - p1[1]);
+}
+export function calculateAzimuth(x1, y1, x2, y2) {
+    const dx = x2 - x1;
+    const dy = y2 - y1;
+    // Note: math.atan2(dx, dy) in Python returns angle from Y-axis. 
+    // In TS Math.atan2(y, x) is standard, but to replicate python `atan2(dx, dy)`:
+    let azimuthRad = Math.atan2(dx, dy);
+    let azimuthDeg = (azimuthRad * 180) / Math.PI;
+    if (azimuthDeg < 0) {
+        azimuthDeg += 360; // Normalize to 0-360°
+    }
+    return azimuthDeg;
+}
+export function rotatePoint(x, y, angleDeg, shiftX, shiftY) {
+    const rad = (angleDeg * Math.PI) / 180;
+    const xNew = x * Math.cos(rad) - y * Math.sin(rad) + shiftX;
+    const yNew = x * Math.sin(rad) + y * Math.cos(rad) + shiftY;
+    return [xNew, yNew, 0];
+}
+export function rotatePointAzimuth(x, y, azimuthDeg, shiftX, shiftY) {
+    // Convert azimuth to math angle (counterclockwise from X-axis)
+    const thetaDeg = 90 - azimuthDeg;
+    return rotatePoint(x, y, thetaDeg, shiftX, shiftY);
+}
+export function isPointInBounds(x, y, xmin, ymin, xmax, ymax) {
+    return x >= xmin && x <= xmax && y >= ymin && y <= ymax;
+}
+export function snapBound(value, step, direction = 'down') {
+    if (direction === 'down') {
+        return Math.floor(value / step) * step;
+    }
+    else {
+        return Math.ceil(value / step) * step;
+    }
+}

package/dist/geometry/offset.utils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Planar polyline offset in drawing units (e.g. UTM meters).
+ *
+ * Every segment is shifted along its normal and neighbouring shifted segments
+ * meet at their intersection (miter join). A corner whose miter point would lie
+ * further than `miterLimit × distance` from the vertex is beveled instead, so
+ * sharp turns do not produce long spikes.
+ */
+import { Coordinate, Coordinate3D } from '../types/index.js';
+export interface LineOffsetOptions {
+    /** Treat the points as a closed ring. Default: true when the first and last point coincide. */
+    closed?: boolean;
+    /** Longest allowed miter as a multiple of the offset distance (default 4). */
+    miterLimit?: number;
+}
+/**
+ * Offset a polyline to one side.
+ *
+ * @param points   polyline vertices ([x, y] or [x, y, z]; z is ignored)
+ * @param distance positive = left of the direction of travel, negative = right
+ * @returns the offset vertices — a ring given with a repeated first point is
+ *          returned the same way; degenerate input returns `[]`
+ */
+export declare function offsetPolyline(points: readonly (Coordinate | Coordinate3D)[], distance: number, opts?: LineOffsetOptions): Coordinate[];
+/**
+ * Offset a polyline to both sides — e.g. canal banks around a centerline.
+ * Distances are in drawing units (UTM meters); returned z values are 0.
+ */
+export declare function getLineOffset(points: readonly (Coordinate | Coordinate3D)[], offsetDistance?: number, opts?: LineOffsetOptions): {
+    left: Coordinate3D[];
+    right: Coordinate3D[];
+};

package/dist/geometry/offset.utils.js

@@ -0,0 +1,87 @@
+/**
+ * Planar polyline offset in drawing units (e.g. UTM meters).
+ *
+ * Every segment is shifted along its normal and neighbouring shifted segments
+ * meet at their intersection (miter join). A corner whose miter point would lie
+ * further than `miterLimit × distance` from the vertex is beveled instead, so
+ * sharp turns do not produce long spikes.
+ */
+const EPS = 1e-9;
+const samePoint = (a, b) => Math.abs(a[0] - b[0]) <= EPS && Math.abs(a[1] - b[1]) <= EPS;
+/**
+ * Offset a polyline to one side.
+ *
+ * @param points   polyline vertices ([x, y] or [x, y, z]; z is ignored)
+ * @param distance positive = left of the direction of travel, negative = right
+ * @returns the offset vertices — a ring given with a repeated first point is
+ *          returned the same way; degenerate input returns `[]`
+ */
+export function offsetPolyline(points, distance, opts = {}) {
+    // Zero-length segments have no direction: drop consecutive duplicates.
+    const pts = [];
+    for (const p of points) {
+        if (!pts.length || !samePoint(p, pts[pts.length - 1]))
+            pts.push([p[0], p[1]]);
+    }
+    const repeatsStart = pts.length > 2 && samePoint(pts[0], pts[pts.length - 1]);
+    let closed = opts.closed ?? repeatsStart;
+    if (closed && repeatsStart)
+        pts.pop();
+    if (closed && pts.length < 3)
+        closed = false;
+    if (pts.length < 2)
+        return [];
+    const n = pts.length;
+    const segments = closed ? n : n - 1;
+    // Left unit normal of each segment.
+    const nx = new Float64Array(segments);
+    const ny = new Float64Array(segments);
+    for (let i = 0; i < segments; i++) {
+        const a = pts[i];
+        const b = pts[(i + 1) % n];
+        const len = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        nx[i] = -(b[1] - a[1]) / len;
+        ny[i] = (b[0] - a[0]) / len;
+    }
+    const limit = opts.miterLimit ?? 4;
+    const out = [];
+    const shifted = (p, seg) => [p[0] + nx[seg] * distance, p[1] + ny[seg] * distance];
+    for (let k = 0; k < n; k++) {
+        const p = pts[k];
+        if (!closed && k === 0) {
+            out.push(shifted(p, 0));
+            continue;
+        }
+        if (!closed && k === n - 1) {
+            out.push(shifted(p, segments - 1));
+            continue;
+        }
+        const prev = k === 0 ? segments - 1 : k - 1;
+        const next = k;
+        // The miter direction is the sum of both normals; |sum| = 2·cos(half the turn angle).
+        const mx = nx[prev] + nx[next];
+        const my = ny[prev] + ny[next];
+        const cosHalf = Math.hypot(mx, my) / 2;
+        if (cosHalf > EPS && 1 / cosHalf <= limit) {
+            const s = distance / (2 * cosHalf * cosHalf);
+            out.push([p[0] + mx * s, p[1] + my * s]);
+        }
+        else {
+            out.push(shifted(p, prev), shifted(p, next));
+        }
+    }
+    if (closed && repeatsStart)
+        out.push([out[0][0], out[0][1]]);
+    return out;
+}
+/**
+ * Offset a polyline to both sides — e.g. canal banks around a centerline.
+ * Distances are in drawing units (UTM meters); returned z values are 0.
+ */
+export function getLineOffset(points, offsetDistance = 1, opts = {}) {
+    const to3D = (pts) => pts.map(p => [p[0], p[1], 0]);
+    return {
+        left: to3D(offsetPolyline(points, offsetDistance, opts)),
+        right: to3D(offsetPolyline(points, -offsetDistance, opts)),
+    };
+}

package/dist/geometry/polyline.utils.d.ts

@@ -0,0 +1,10 @@
+import { Coordinate } from '../types/index.js';
+export declare function kmPointPolyline(points: Coordinate[], targetDistance: number): {
+    point: Coordinate;
+    az: number;
+};
+export declare function dividePolylineWithDistance(coords: Coordinate[], segmentLength?: number): {
+    points: Coordinate[];
+    distances: number[];
+    angles: number[];
+};

package/dist/geometry/polyline.utils.js

@@ -0,0 +1,63 @@
+import { calculateAzimuth, calculateDistance } from './math.utils.js';
+export function kmPointPolyline(points, targetDistance) {
+    let totalDistance = 0;
+    for (let i = 0; i < points.length - 1; i++) {
+        const [x1, y1] = points[i];
+        const [x2, y2] = points[i + 1];
+        const az = calculateAzimuth(x1, y1, x2, y2);
+        const segmentLength = Math.hypot(x2 - x1, y2 - y1);
+        if (totalDistance + segmentLength >= targetDistance) {
+            // Remaining distance in this segment
+            const remain = targetDistance - totalDistance;
+            const ratio = remain / segmentLength;
+            const x = x1 + (x2 - x1) * ratio;
+            const y = y1 + (y2 - y1) * ratio;
+            return { point: [x, y], az };
+        }
+        totalDistance += segmentLength;
+    }
+    // If targetDistance > total length -> return last point
+    const lastPoint = points[points.length - 1];
+    let az = 0;
+    if (points.length >= 2) {
+        const [x1, y1] = points[points.length - 2];
+        const [x2, y2] = points[points.length - 1];
+        az = calculateAzimuth(x1, y1, x2, y2);
+    }
+    return { point: lastPoint, az };
+}
+export function dividePolylineWithDistance(coords, segmentLength = 100) {
+    if (coords.length === 0)
+        return { points: [], distances: [], angles: [] };
+    const newPoints = [coords[0]];
+    const distances = [0];
+    const angles = [];
+    let totalDistance = 0;
+    let firstLoop = true;
+    let az = 0;
+    for (let i = 1; i < coords.length; i++) {
+        const [x1, y1] = coords[i - 1];
+        const [x2, y2] = coords[i];
+        az = calculateAzimuth(x1, y1, x2, y2);
+        if (firstLoop) {
+            angles.push(az);
+            firstLoop = false;
+        }
+        const segmentDist = calculateDistance([x1, y1], [x2, y2]);
+        while (totalDistance + segmentLength <= segmentDist) {
+            totalDistance += segmentLength;
+            const t = totalDistance / segmentDist;
+            const newX = x1 + t * (x2 - x1);
+            const newY = y1 + t * (y2 - y1);
+            newPoints.push([newX, newY]);
+            distances.push(distances[distances.length - 1] + segmentLength);
+            angles.push(az);
+        }
+        totalDistance -= segmentDist;
+    }
+    newPoints.push(coords[coords.length - 1]);
+    const lastDist = calculateDistance(newPoints[newPoints.length - 2], newPoints[newPoints.length - 1]);
+    distances.push(distances[distances.length - 1] + lastDist);
+    angles.push(az);
+    return { points: newPoints, distances, angles };
+}

package/dist/geometry/text.utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Text measurement helpers.
+ *
+ * DXF carries no font metrics, so widths are estimates: count the characters
+ * that advance the pen (Thai above/below vowels and tone marks do not) and
+ * multiply by an average glyph width.
+ */
+/** Number of characters in `text` that take horizontal space. */
+export declare function visibleCharCount(text: string): number;
+/**
+ * Estimated width of a single line of text.
+ * @param widthFactor average glyph advance as a fraction of the text height
+ *                    (≈0.6–0.7 for Thai TrueType fonts, ≈0.9 for txt.shx)
+ */
+export declare function estimateTextWidth(text: string, height: number, widthFactor?: number): number;

package/dist/geometry/text.utils.js

@@ -0,0 +1,28 @@
+/**
+ * Text measurement helpers.
+ *
+ * DXF carries no font metrics, so widths are estimates: count the characters
+ * that advance the pen (Thai above/below vowels and tone marks do not) and
+ * multiply by an average glyph width.
+ */
+/** Thai combining marks that sit above/below a base character (no advance). */
+function isThaiCombining(code) {
+    return code === 0x0e31 || (code >= 0x0e34 && code <= 0x0e3a) || (code >= 0x0e47 && code <= 0x0e4e);
+}
+/** Number of characters in `text` that take horizontal space. */
+export function visibleCharCount(text) {
+    let n = 0;
+    for (const ch of text) {
+        if (!isThaiCombining(ch.codePointAt(0)))
+            n++;
+    }
+    return n;
+}
+/**
+ * Estimated width of a single line of text.
+ * @param widthFactor average glyph advance as a fraction of the text height
+ *                    (≈0.6–0.7 for Thai TrueType fonts, ≈0.9 for txt.shx)
+ */
+export function estimateTextWidth(text, height, widthFactor = 0.75) {
+    return visibleCharCount(text) * height * widthFactor;
+}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * onfarm-dxf-ts — public API.
+ *
+ * A pure, API-agnostic, browser-first DXF generation library. Feed it plain
+ * coordinates, labels and style options (optionally on top of a DXF template)
+ * and it produces a DXF string/file. It knows nothing about any backend.
+ */
+export { DxfBuilder } from './core/dxf-builder.js';
+export type { CalloutOptions, ImageOptions } from './core/dxf-builder.js';
+export { DxfDocument } from './core/dxf-document.js';
+export { Modelspace } from './core/modelspace.js';
+export * from './core/dxf-entities.js';
+export * from './core/hatch-patterns.js';
+export * from './types/index.js';
+export * from './template/index.js';
+export { DxfParser } from './parser/index.js';
+export type { ParsedDxf, DxfBlock as ParsedDxfBlock, DxfEntity as ParsedDxfEntity, DxfPoint as ParsedDxfPoint, } from './parser/index.js';
+export * from './geometry/math.utils.js';
+export * from './geometry/polyline.utils.js';
+export * from './geometry/offset.utils.js';
+export * from './geometry/text.utils.js';
+export * from './symbols/structures.js';
+export * from './symbols/slope-symbol.js';

package/dist/index.js

@@ -0,0 +1,29 @@
+/**
+ * onfarm-dxf-ts — public API.
+ *
+ * A pure, API-agnostic, browser-first DXF generation library. Feed it plain
+ * coordinates, labels and style options (optionally on top of a DXF template)
+ * and it produces a DXF string/file. It knows nothing about any backend.
+ */
+// Core engine
+export { DxfBuilder } from './core/dxf-builder.js';
+export { DxfDocument } from './core/dxf-document.js';
+export { Modelspace } from './core/modelspace.js';
+export * from './core/dxf-entities.js';
+export * from './core/hatch-patterns.js';
+// Generic types (Coordinate, Coordinate3D, OnfarmLine)
+export * from './types/index.js';
+// Template handling (block registry; reader/injector live in core for now)
+export * from './template/index.js';
+// Internal DXF parser (TypeScript port of dxf-parser — no external dependency).
+// DxfEntity/DxfPoint are renamed with a Parsed- prefix to avoid clashing with
+// the builder-side types exported from core/dxf-entities.
+export { DxfParser } from './parser/index.js';
+// Geometry utilities (pure math — azimuth, polyline division, offsets)
+export * from './geometry/math.utils.js';
+export * from './geometry/polyline.utils.js';
+export * from './geometry/offset.utils.js';
+export * from './geometry/text.utils.js';
+// Parametric symbol generators (check / box / culvert / flume / siphon …)
+export * from './symbols/structures.js';
+export * from './symbols/slope-symbol.js';

package/dist/parser/auto-cad-color-index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * AutoCad files sometimes use an indexed color value between 1 and 255 inclusive.
+ * Each value corresponds to a color. index 1 is red, that is 16711680 or 0xFF0000.
+ * index 0 and 256, while included in this array, are actually reserved for inheritance
+ * values in AutoCad so they should not be used for index color lookups.
+ */
+declare const AUTO_CAD_COLOR_INDEX: readonly number[];
+export default AUTO_CAD_COLOR_INDEX;

package/dist/parser/auto-cad-color-index.js

@@ -0,0 +1,265 @@
+/**
+ * AutoCad files sometimes use an indexed color value between 1 and 255 inclusive.
+ * Each value corresponds to a color. index 1 is red, that is 16711680 or 0xFF0000.
+ * index 0 and 256, while included in this array, are actually reserved for inheritance
+ * values in AutoCad so they should not be used for index color lookups.
+ */
+const AUTO_CAD_COLOR_INDEX = [
+    0,
+    16711680,
+    16776960,
+    65280,
+    65535,
+    255,
+    16711935,
+    16777215,
+    8421504,
+    12632256,
+    16711680,
+    16744319,
+    13369344,
+    13395558,
+    10027008,
+    10046540,
+    8323072,
+    8339263,
+    4980736,
+    4990502,
+    16727808,
+    16752511,
+    13382400,
+    13401958,
+    10036736,
+    10051404,
+    8331008,
+    8343359,
+    4985600,
+    4992806,
+    16744192,
+    16760703,
+    13395456,
+    13408614,
+    10046464,
+    10056268,
+    8339200,
+    8347455,
+    4990464,
+    4995366,
+    16760576,
+    16768895,
+    13408512,
+    13415014,
+    10056192,
+    10061132,
+    8347392,
+    8351551,
+    4995328,
+    4997670,
+    16776960,
+    16777087,
+    13421568,
+    13421670,
+    10000384,
+    10000460,
+    8355584,
+    8355647,
+    5000192,
+    5000230,
+    12582656,
+    14679935,
+    10079232,
+    11717734,
+    7510016,
+    8755276,
+    6258432,
+    7307071,
+    3755008,
+    4344870,
+    8388352,
+    12582783,
+    6736896,
+    10079334,
+    5019648,
+    7510092,
+    4161280,
+    6258495,
+    2509824,
+    3755046,
+    4194048,
+    10485631,
+    3394560,
+    8375398,
+    2529280,
+    6264908,
+    2064128,
+    5209919,
+    1264640,
+    3099686,
+    65280,
+    8388479,
+    52224,
+    6736998,
+    38912,
+    5019724,
+    32512,
+    4161343,
+    19456,
+    2509862,
+    65343,
+    8388511,
+    52275,
+    6737023,
+    38950,
+    5019743,
+    32543,
+    4161359,
+    19475,
+    2509871,
+    65407,
+    8388543,
+    52326,
+    6737049,
+    38988,
+    5019762,
+    32575,
+    4161375,
+    19494,
+    2509881,
+    65471,
+    8388575,
+    52377,
+    6737074,
+    39026,
+    5019781,
+    32607,
+    4161391,
+    19513,
+    2509890,
+    65535,
+    8388607,
+    52428,
+    6737100,
+    39064,
+    5019800,
+    32639,
+    4161407,
+    19532,
+    2509900,
+    49151,
+    8380415,
+    39372,
+    6730444,
+    29336,
+    5014936,
+    24447,
+    4157311,
+    14668,
+    2507340,
+    32767,
+    8372223,
+    26316,
+    6724044,
+    19608,
+    5010072,
+    16255,
+    4153215,
+    9804,
+    2505036,
+    16383,
+    8364031,
+    13260,
+    6717388,
+    9880,
+    5005208,
+    8063,
+    4149119,
+    4940,
+    2502476,
+    255,
+    8355839,
+    204,
+    6710988,
+    152,
+    5000344,
+    127,
+    4145023,
+    76,
+    2500172,
+    4129023,
+    10452991,
+    3342540,
+    8349388,
+    2490520,
+    6245528,
+    2031743,
+    5193599,
+    1245260,
+    3089996,
+    8323327,
+    12550143,
+    6684876,
+    10053324,
+    4980888,
+    7490712,
+    4128895,
+    6242175,
+    2490444,
+    3745356,
+    12517631,
+    14647295,
+    10027212,
+    11691724,
+    7471256,
+    8735896,
+    6226047,
+    7290751,
+    3735628,
+    4335180,
+    16711935,
+    16744447,
+    13369548,
+    13395660,
+    9961624,
+    9981080,
+    8323199,
+    8339327,
+    4980812,
+    4990540,
+    16711871,
+    16744415,
+    13369497,
+    13395634,
+    9961586,
+    9981061,
+    8323167,
+    8339311,
+    4980793,
+    4990530,
+    16711807,
+    16744383,
+    13369446,
+    13395609,
+    9961548,
+    9981042,
+    8323135,
+    8339295,
+    4980774,
+    4990521,
+    16711743,
+    16744351,
+    13369395,
+    13395583,
+    9961510,
+    9981023,
+    8323103,
+    8339279,
+    4980755,
+    4990511,
+    3355443,
+    5987163,
+    8684676,
+    11382189,
+    14079702,
+    16777215
+];
+export default AUTO_CAD_COLOR_INDEX;

package/dist/parser/dim-style-codes.d.ts

@@ -0,0 +1,5 @@
+/** Dimension style variables are used either in DIMSTYLE table or in DIMENSION entity style
+ * override in XDATA.
+ */
+declare const codes: ReadonlyMap<number, string>;
+export default codes;

package/dist/parser/dim-style-codes.js

@@ -0,0 +1,32 @@
+/** Dimension style variables are used either in DIMSTYLE table or in DIMENSION entity style
+ * override in XDATA.
+ */
+const codes = new Map([
+    [140, 'DIMTXT'],
+    [142, 'DIMTSZ'],
+    [144, 'DIMLFAC'],
+    [147, 'DIMGAP'],
+    [173, 'DIMSAH'],
+    [175, 'DIMSOXD'],
+    [176, 'DIMCLRD'],
+    [177, 'DIMCLRE'],
+    [178, 'DIMCLRT'],
+    [271, 'DIMDEC'],
+    [278, 'DIMDSEP'],
+    [281, 'DIMSD1'],
+    [282, 'DIMSD2'],
+    [3, 'DIMPOST'],
+    [40, 'DIMSCALE'],
+    [41, 'DIMASZ'],
+    [42, 'DIMEXO'],
+    [44, 'DIMEXE'],
+    [45, 'DIMRND'],
+    [46, 'DIMDLE'],
+    [5, 'DIMBLK'],
+    [6, 'DIMBLK1'],
+    [7, 'DIMBLK2'],
+    [75, 'DIMSE1'],
+    [76, 'DIMSE2'],
+    [78, 'DIMZIN'],
+]);
+export default codes;

package/dist/parser/dxf-parser.d.ts

@@ -0,0 +1,16 @@
+/**
+ * DxfParser — TypeScript port of the `dxf-parser` package (see parser-raw/
+ * for the original JS source). Parses a DXF string into structured data:
+ * header, tables (layers, line types, styles, …), blocks and entities.
+ *
+ * Browser-first: only `parseSync(source: string)` is provided (the original's
+ * Node-stream `parseStream` was dropped).
+ */
+import { IEntityParserType, ParsedDxf } from './types.js';
+export default class DxfParser {
+    private _entityHandlers;
+    constructor();
+    registerEntityHandler(handlerType: IEntityParserType): void;
+    parseSync(source: string): ParsedDxf | null;
+    private _parse;
+}