@miclivs/cadcli 0.1.2 → 0.3.0

package/dist/core/acad-edit.d.ts

@@ -0,0 +1,142 @@
+export type AcadPoint = {
+    x: number;
+    y: number;
+    z?: number;
+};
+export type AcadColor = {
+    mode: "byLayer";
+} | {
+    mode: "byBlock";
+} | {
+    mode: "index";
+    index: number;
+} | {
+    mode: "rgb";
+    r: number;
+    g: number;
+    b: number;
+};
+export type AcadEditOperation = {
+    kind: "setText";
+    entityId: string;
+    text: string;
+} | {
+    kind: "setLayer";
+    entityId: string;
+    layer: string;
+} | {
+    kind: "setColor";
+    entityId: string;
+    color: AcadColor;
+} | {
+    kind: "setLineType";
+    entityId: string;
+    lineType: string;
+} | {
+    kind: "setLineWeight";
+    entityId: string;
+    weight: number;
+} | {
+    kind: "setTransparency";
+    entityId: string;
+    alpha: number;
+} | {
+    kind: "setVisibility";
+    entityId: string;
+    visible: boolean;
+} | {
+    kind: "move";
+    entityId: string;
+    dx: number;
+    dy: number;
+    dz?: number;
+} | {
+    kind: "rotate";
+    entityId: string;
+    angleDegrees: number;
+    origin?: AcadPoint;
+} | {
+    kind: "scale";
+    entityId: string;
+    factor: number;
+    origin?: AcadPoint;
+} | {
+    kind: "copy";
+    entityId: string;
+    dx?: number;
+    dy?: number;
+    dz?: number;
+} | {
+    kind: "matchProperties";
+    entityId: string;
+    sourceId: string;
+} | {
+    kind: "setAttribute";
+    entityId: string;
+    tag: string;
+    value: string;
+} | {
+    kind: "delete";
+    entityId: string;
+} | {
+    kind: "addPoint";
+    at: AcadPoint;
+    layer?: string;
+    color?: AcadColor;
+} | {
+    kind: "addLine";
+    from: AcadPoint;
+    to: AcadPoint;
+    layer?: string;
+    color?: AcadColor;
+} | {
+    kind: "addCircle";
+    center: AcadPoint;
+    radius: number;
+    layer?: string;
+    color?: AcadColor;
+} | {
+    kind: "addArc";
+    center: AcadPoint;
+    radius: number;
+    startAngleDegrees: number;
+    endAngleDegrees: number;
+    layer?: string;
+    color?: AcadColor;
+} | {
+    kind: "addText";
+    text: string;
+    at: AcadPoint;
+    height?: number;
+    rotationDegrees?: number;
+    layer?: string;
+    color?: AcadColor;
+} | {
+    kind: "addMText";
+    text: string;
+    at: AcadPoint;
+    height?: number;
+    width?: number;
+    rotationDegrees?: number;
+    layer?: string;
+    color?: AcadColor;
+} | {
+    kind: "addPolyline";
+    points: AcadPoint[];
+    closed?: boolean;
+    layer?: string;
+    color?: AcadColor;
+};
+export interface AcadEditResult {
+    input: string;
+    output: string;
+    backend: "acad-ts";
+    operations: AcadEditOperation[];
+    changed: number;
+}
+export declare function editWithAcadTs(opts: {
+    input: string;
+    output: string;
+    operations: AcadEditOperation[];
+    overwrite?: boolean;
+}): AcadEditResult;

package/dist/core/acad-edit.js

@@ -0,0 +1,234 @@
+import { Arc, Circle, Color, Insert, Layer, Line, LineType, LineWeightType, LwPolyline, MText, Point, TextEntity, Transparency, XY, XYZ, } from "@node-projects/acad-ts";
+import { EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { readAcadFile, writeAcadDocument } from "./acad.js";
+import { DwgCliError } from "./errors.js";
+import { writeOutput } from "./files.js";
+const degreesToRadians = (degrees) => (degrees * Math.PI) / 180;
+function xyz(point) {
+    return new XYZ(point.x, point.y, point.z ?? 0);
+}
+function xy(point) {
+    return new XY(point.x, point.y);
+}
+function handleMatches(handle, entityId) {
+    const expected = entityId.toLowerCase();
+    const text = String(handle ?? "").toLowerCase();
+    if (text === expected)
+        return true;
+    const numeric = Number(handle);
+    return (Number.isFinite(numeric) && numeric.toString(16).toLowerCase() === expected);
+}
+function modelEntities(doc) {
+    return [...(doc.modelSpace?.entities ?? [])];
+}
+function findEntity(doc, entityId) {
+    const entity = modelEntities(doc).find((item) => handleMatches(item.handle, entityId));
+    if (!entity) {
+        throw new DwgCliError(`Entity not found: ${entityId}`, "ENTITY_NOT_FOUND", EXIT_USER_ERROR);
+    }
+    return entity;
+}
+function ensureLayer(doc, name) {
+    const existing = doc.layers?.tryGetValue(name);
+    if (existing)
+        return existing;
+    const layer = new Layer(name);
+    doc.layers?.add(layer);
+    return layer;
+}
+function ensureLineType(doc, name) {
+    const existing = doc.lineTypes?.tryGetValue(name);
+    if (existing)
+        return existing;
+    const lineType = new LineType(name);
+    doc.lineTypes?.add(lineType);
+    return lineType;
+}
+function acadColor(color) {
+    switch (color.mode) {
+        case "byLayer":
+            return Color.byLayer;
+        case "byBlock":
+            return Color.byBlock;
+        case "index":
+            return new Color(color.index);
+        case "rgb":
+            return new Color(color.r, color.g, color.b);
+    }
+}
+function lineWeight(weight) {
+    if (!Object.values(LineWeightType).includes(weight)) {
+        throw new DwgCliError(`Unsupported line weight: ${weight}`, "INVALID_LINE_WEIGHT", EXIT_USER_ERROR);
+    }
+    return weight;
+}
+function applyCommonOptions(doc, entity, options) {
+    if (options.layer)
+        entity.layer = ensureLayer(doc, options.layer);
+    if (options.color)
+        entity.color = acadColor(options.color);
+}
+function addEntity(doc, entity) {
+    if (!doc.modelSpace) {
+        throw new DwgCliError("Drawing has no model space to edit.", "MODEL_SPACE_NOT_FOUND", EXIT_USER_ERROR);
+    }
+    doc.modelSpace.entities.add(entity);
+}
+function deleteEntity(entity, entityId) {
+    const owner = entity.owner;
+    if (!owner?.entities?.remove) {
+        throw new DwgCliError(`Entity cannot be deleted: ${entityId}`, "ENTITY_NOT_DELETABLE", EXIT_USER_ERROR);
+    }
+    owner.entities.remove(entity);
+}
+function setAttribute(entity, tag, value, id) {
+    if (!(entity instanceof Insert)) {
+        throw new DwgCliError(`Entity is not a block insert: ${id}`, "ENTITY_NOT_INSERT", EXIT_USER_ERROR);
+    }
+    const attr = [...entity.attributes].find((item) => item.tag.toLowerCase() === tag.toLowerCase());
+    if (!attr) {
+        throw new DwgCliError(`Attribute not found on ${id}: ${tag}`, "ATTRIBUTE_NOT_FOUND", EXIT_USER_ERROR);
+    }
+    attr.value = value;
+}
+function applyOperation(doc, operation) {
+    switch (operation.kind) {
+        case "addPoint": {
+            const point = new Point(xyz(operation.at));
+            applyCommonOptions(doc, point, operation);
+            addEntity(doc, point);
+            return;
+        }
+        case "addLine": {
+            const line = new Line(xyz(operation.from), xyz(operation.to));
+            applyCommonOptions(doc, line, operation);
+            addEntity(doc, line);
+            return;
+        }
+        case "addCircle": {
+            const circle = new Circle();
+            circle.center = xyz(operation.center);
+            circle.radius = operation.radius;
+            applyCommonOptions(doc, circle, operation);
+            addEntity(doc, circle);
+            return;
+        }
+        case "addArc": {
+            const arc = new Arc(xyz(operation.center), operation.radius, degreesToRadians(operation.startAngleDegrees), degreesToRadians(operation.endAngleDegrees));
+            applyCommonOptions(doc, arc, operation);
+            addEntity(doc, arc);
+            return;
+        }
+        case "addText": {
+            const text = new TextEntity();
+            text.value = operation.text;
+            text.insertPoint = xyz(operation.at);
+            if (operation.height !== undefined)
+                text.height = operation.height;
+            if (operation.rotationDegrees !== undefined) {
+                text.rotation = degreesToRadians(operation.rotationDegrees);
+            }
+            applyCommonOptions(doc, text, operation);
+            addEntity(doc, text);
+            return;
+        }
+        case "addMText": {
+            const text = new MText();
+            text.value = operation.text;
+            text.insertPoint = xyz(operation.at);
+            if (operation.height !== undefined)
+                text.height = operation.height;
+            if (operation.width !== undefined)
+                text.rectangleWidth = operation.width;
+            if (operation.rotationDegrees !== undefined) {
+                text.rotation = degreesToRadians(operation.rotationDegrees);
+            }
+            applyCommonOptions(doc, text, operation);
+            addEntity(doc, text);
+            return;
+        }
+        case "addPolyline": {
+            const polyline = new LwPolyline(operation.points.map(xy));
+            polyline.isClosed = operation.closed ?? false;
+            applyCommonOptions(doc, polyline, operation);
+            addEntity(doc, polyline);
+            return;
+        }
+    }
+    const entity = findEntity(doc, operation.entityId);
+    switch (operation.kind) {
+        case "setText":
+            if (!(entity instanceof TextEntity || entity instanceof MText)) {
+                throw new DwgCliError(`Entity is not editable text: ${operation.entityId}`, "ENTITY_NOT_TEXT", EXIT_USER_ERROR);
+            }
+            entity.value = operation.text;
+            return;
+        case "setLayer":
+            entity.layer = ensureLayer(doc, operation.layer);
+            return;
+        case "setColor":
+            entity.color = acadColor(operation.color);
+            return;
+        case "setLineType":
+            entity.lineType = ensureLineType(doc, operation.lineType);
+            return;
+        case "setLineWeight":
+            entity.lineWeight = lineWeight(operation.weight);
+            return;
+        case "setTransparency":
+            entity.transparency = Transparency.fromAlphaValue(operation.alpha);
+            return;
+        case "setVisibility":
+            entity.isInvisible = !operation.visible;
+            return;
+        case "move":
+            entity.applyTranslation(new XYZ(operation.dx, operation.dy, operation.dz ?? 0));
+            return;
+        case "rotate": {
+            const origin = operation.origin ? xyz(operation.origin) : XYZ.zero;
+            entity.applyTranslation(new XYZ(-origin.x, -origin.y, -origin.z));
+            entity.applyRotation(XYZ.axisZ, degreesToRadians(operation.angleDegrees));
+            entity.applyTranslation(origin);
+            return;
+        }
+        case "scale":
+            entity.applyScaling(new XYZ(operation.factor, operation.factor, operation.factor), operation.origin ? xyz(operation.origin) : XYZ.zero);
+            return;
+        case "copy": {
+            const clone = entity.clone();
+            clone.applyTranslation(new XYZ(operation.dx ?? 0, operation.dy ?? 0, operation.dz ?? 0));
+            addEntity(doc, clone);
+            return;
+        }
+        case "matchProperties": {
+            const source = findEntity(doc, operation.sourceId);
+            entity.matchProperties(source);
+            return;
+        }
+        case "setAttribute":
+            setAttribute(entity, operation.tag, operation.value, operation.entityId);
+            return;
+        case "delete":
+            deleteEntity(entity, operation.entityId);
+            return;
+    }
+}
+export function editWithAcadTs(opts) {
+    if (opts.operations.length === 0) {
+        throw new DwgCliError("No acad-ts edit operation specified.", "MISSING_EDIT_OPERATION", EXIT_USER_ERROR);
+    }
+    if (opts.input === opts.output && !opts.overwrite) {
+        throw new DwgCliError("Refusing to edit in place without --overwrite. Provide --output or pass --overwrite.", "EDIT_REQUIRES_OUTPUT_OR_OVERWRITE", EXIT_USER_ERROR);
+    }
+    const { bytes, doc, format } = readAcadFile(opts.input);
+    for (const operation of opts.operations)
+        applyOperation(doc, operation);
+    writeOutput(opts.output, writeAcadDocument(doc, format, bytes.length));
+    return {
+        input: opts.input,
+        output: opts.output,
+        backend: "acad-ts",
+        operations: opts.operations,
+        changed: opts.operations.length,
+    };
+}

package/dist/core/acad-view.d.ts

@@ -0,0 +1,6 @@
+export interface AcadSvgViewResult {
+    input: string;
+    svg: string;
+    backend: "acad-ts";
+}
+export declare function renderSvgWithAcadTs(file: string): AcadSvgViewResult;

package/dist/core/acad-view.js

@@ -0,0 +1,22 @@
+import { Color } from "@node-projects/acad-ts";
+import { readAcadFile, writeAcadSvg } from "./acad.js";
+// acad-ts SvgWriter currently crashes when text resolves ByLayer/ByBlock
+// through an index that has no RGB entry. Normalize render-only colors here;
+// the source file is untouched because view reparses the document every time.
+function makeEntityColorsRenderable(doc) {
+    for (const entity of doc.modelSpace?.entities ?? []) {
+        const candidate = entity;
+        if (candidate.color?.isByLayer || candidate.color?.isByBlock) {
+            candidate.color = Color.black;
+        }
+    }
+}
+export function renderSvgWithAcadTs(file) {
+    const { doc } = readAcadFile(file);
+    makeEntityColorsRenderable(doc);
+    return {
+        input: file,
+        svg: writeAcadSvg(doc),
+        backend: "acad-ts",
+    };
+}

package/dist/core/acad.d.ts

@@ -0,0 +1,11 @@
+import { type CadDocument } from "@node-projects/acad-ts";
+import type { DwgFormat } from "../types.js";
+export interface AcadFile {
+    bytes: Uint8Array;
+    doc: CadDocument;
+    format: DwgFormat;
+}
+export declare function parseAcadDocument(bytes: Uint8Array, format: DwgFormat): CadDocument;
+export declare function readAcadFile(file: string): AcadFile;
+export declare function writeAcadDocument(doc: CadDocument, format: DwgFormat, originalBytes: number): Uint8Array;
+export declare function writeAcadSvg(doc: CadDocument): string;

package/dist/core/acad.js

@@ -0,0 +1,82 @@
+import { DwgReader, DwgWriter, DxfReader, DxfWriter, SvgWriter, } from "@node-projects/acad-ts";
+import { EXIT_USER_ERROR } from "../utils/exit-codes.js";
+import { arrayBufferFor } from "./adapter.js";
+import { DwgCliError } from "./errors.js";
+import { readCadFile } from "./files.js";
+export function parseAcadDocument(bytes, format) {
+    try {
+        return format === "DWG"
+            ? DwgReader.readFromStream(arrayBufferFor(bytes))
+            : DxfReader.readFromStream(bytes);
+    }
+    catch (error) {
+        throw new DwgCliError(`Could not parse ${format}: ${error.message}`, "PARSE_FAILED", EXIT_USER_ERROR);
+    }
+}
+export function readAcadFile(file) {
+    const { bytes, format } = readCadFile(file);
+    return { bytes, format, doc: parseAcadDocument(bytes, format) };
+}
+function writeDwg(doc, originalBytes) {
+    let size = Math.max(1024 * 1024, originalBytes * 4);
+    const maxSize = 512 * 1024 * 1024;
+    while (size <= maxSize) {
+        const buffer = new ArrayBuffer(size);
+        const writer = new DwgWriter(buffer, doc);
+        writer.write();
+        if (writer.bytesWritten <= size) {
+            return new Uint8Array(buffer).slice(0, writer.bytesWritten);
+        }
+        size *= 2;
+    }
+    throw new DwgCliError("Could not write DWG: output exceeded the maximum supported buffer size.", "ACAD_WRITE_FAILED", EXIT_USER_ERROR);
+}
+function writeDxf(doc) {
+    let content = "";
+    DxfWriter.writeToStream({
+        write(value) {
+            content +=
+                typeof value === "string" ? value : new TextDecoder().decode(value);
+        },
+        flush() { },
+        close() { },
+    }, doc);
+    return new TextEncoder().encode(content);
+}
+export function writeAcadDocument(doc, format, originalBytes) {
+    try {
+        return format === "DWG" ? writeDwg(doc, originalBytes) : writeDxf(doc);
+    }
+    catch (error) {
+        if (error instanceof DwgCliError)
+            throw error;
+        throw new DwgCliError(`Could not write ${format}: ${error.message}`, "ACAD_WRITE_FAILED", EXIT_USER_ERROR);
+    }
+}
+function trimNullPadding(bytes) {
+    const end = bytes.indexOf(0);
+    return end === -1 ? bytes : bytes.slice(0, end);
+}
+function isOutputCapacityError(error) {
+    return /offset is out of bounds|too small|outside the bounds/i.test(error.message);
+}
+export function writeAcadSvg(doc) {
+    let size = 1024 * 1024;
+    const maxSize = 256 * 1024 * 1024;
+    while (size <= maxSize) {
+        const output = new Uint8Array(size);
+        try {
+            const writer = new SvgWriter(output, doc);
+            writer.write();
+            writer.dispose();
+            return new TextDecoder().decode(trimNullPadding(output));
+        }
+        catch (error) {
+            if (!isOutputCapacityError(error) || size >= maxSize) {
+                throw new DwgCliError(`Could not render SVG with acad-ts: ${error.message}`, "ACAD_SVG_FAILED", EXIT_USER_ERROR);
+            }
+            size *= 2;
+        }
+    }
+    throw new DwgCliError("Could not render SVG with acad-ts: output exceeded the maximum supported buffer size.", "ACAD_SVG_FAILED", EXIT_USER_ERROR);
+}

package/dist/core/adapter.d.ts

@@ -6,9 +6,3 @@ export declare class AcadTsReader implements DrawingReader {
     parse(_file: string, bytes: Uint8Array, format: DwgFormat): Promise<unknown>;
     thumbnail(): Promise<ThumbnailResult | null>;
 }
-export declare class NativeLibreDwgReader implements DrawingReader {
-    private readonly toolDir?;
-    constructor(toolDir?: string | undefined);
-    parse(file: string, _bytes: Uint8Array, _format: DwgFormat): Promise<unknown>;
-    thumbnail(): Promise<ThumbnailResult | null>;
-}

package/dist/core/adapter.js

@@ -1,7 +1,6 @@
 import { DwgReader, DxfReader } from "@node-projects/acad-ts";
 import { EXIT_UNAVAILABLE, EXIT_USER_ERROR } from "../utils/exit-codes.js";
 import { DwgCliError } from "./errors.js";
-import { readJsonWithLibreDwg } from "./libredwg.js";
 function asRecord(value) {
     return value && typeof value === "object"
         ? value
@@ -67,6 +66,14 @@ function blockName(entity) {
     const block = asRecord(entity).block;
     return valueString(asRecord(block).name);
 }
+function textStyle(entity) {
+    const style = asRecord(entity)._style ?? asRecord(entity).style;
+    const rec = asRecord(style);
+    return {
+        name: valueString(rec.name ?? rec._name),
+        file: valueString(rec.filename),
+    };
+}
 function vertices(entity) {
     const raw = asRecord(entity).vertices;
     if (!Array.isArray(raw))
@@ -113,8 +120,14 @@ function normalizeAcadEntity(entity) {
         data.startAngle = rec.startAngle;
     if (typeof rec.endAngle === "number")
         data.endAngle = rec.endAngle;
-    if (text)
+    if (text) {
+        const style = textStyle(entity);
         data.text = text;
+        if (style.name)
+            data.textStyle = style.name;
+        if (style.file)
+            data.textStyleFile = style.file;
+    }
     if (name)
         data.blockName = name;
     return data;
@@ -130,6 +143,7 @@ export function normalizeAcadDocument(doc) {
     const entities = items(doc.modelSpace?.entities).map(normalizeAcadEntity);
     return {
         version: doc.header?.versionString ?? String(doc.header?.version ?? ""),
+        codePage: doc.header?.codePage,
         layers,
         blocks,
         entities,
@@ -151,15 +165,3 @@ export class AcadTsReader {
         throw new DwgCliError("Thumbnail extraction is not available through acad-ts.", "THUMBNAIL_UNAVAILABLE", EXIT_UNAVAILABLE);
     }
 }
-export class NativeLibreDwgReader {
-    toolDir;
-    constructor(toolDir) {
-        this.toolDir = toolDir;
-    }
-    async parse(file, _bytes, _format) {
-        return readJsonWithLibreDwg(file, { toolDir: this.toolDir }).json;
-    }
-    async thumbnail() {
-        throw new DwgCliError("Thumbnail extraction is not available through native LibreDWG.", "THUMBNAIL_UNAVAILABLE", EXIT_UNAVAILABLE);
-    }
-}

package/dist/core/drawing.d.ts

@@ -1,7 +1,6 @@
 import type { DrawingReader, DwgBlock, DwgDocument, DwgEntity, DwgLayer, EntityFilter, SvgResult, ThumbnailResult } from "../types.js";
 export interface LoadOptions {
     reader?: DrawingReader;
-    toolDir?: string;
 }
 export declare function loadDrawing(file: string, opts?: LoadOptions): Promise<DwgDocument>;
 export declare function getInfo(file: string, opts?: LoadOptions): Promise<import("../types.js").DwgSummary>;

package/dist/core/drawing.js

@@ -4,13 +4,14 @@ import { DwgCliError } from "./errors.js";
 import { readCadFile } from "./files.js";
 import { normalizeDocument } from "./normalize.js";
 import { renderSvg } from "./svg.js";
+import { normalizeTextAuto } from "./text-normalize.js";
 function readerFor(opts) {
     return opts.reader ?? new AcadTsReader();
 }
 export async function loadDrawing(file, opts = {}) {
     const { bytes, format } = readCadFile(file);
     const raw = await readerFor(opts).parse(file, bytes, format);
-    return normalizeDocument(file, format, raw);
+    return normalizeTextAuto(normalizeDocument(file, format, raw));
 }
 export async function getInfo(file, opts) {
     return (await loadDrawing(file, opts)).summary;

package/dist/core/normalize.js

@@ -140,6 +140,9 @@ export function normalizeDocument(file, format, raw) {
     const layers = normalizeLayers(firstArray(root, LAYER_ARRAY_FIELDS), entities);
     const blocks = normalizeBlocks(firstArray(root, BLOCK_ARRAY_FIELDS));
     const version = stringField(root, ["version", "headerVersion", "dwgVersion"]);
+    const metadata = {
+        codePage: stringField(root, ["codePage", "encoding"]),
+    };
     const summary = {
         file: basename(file),
         format,
@@ -152,5 +155,5 @@ export function normalizeDocument(file, format, raw) {
         },
         bounds: computeBounds(entities),
     };
-    return { summary, layers, blocks, entities, unsupported, raw };
+    return { summary, metadata, layers, blocks, entities, unsupported, raw };
 }

package/dist/core/query.d.ts

@@ -0,0 +1,17 @@
+import type { DwgDocument } from "../types.js";
+export interface QuerySchemaColumn {
+    name: string;
+    type: "text" | "integer" | "real";
+}
+export interface QuerySchemaTable {
+    name: string;
+    description: string;
+    columns: QuerySchemaColumn[];
+}
+export interface QueryResult {
+    columns: string[];
+    rows: Record<string, unknown>[];
+}
+export declare function querySchema(): string;
+export declare function querySchemaTables(): QuerySchemaTable[];
+export declare function queryDrawing(doc: DwgDocument, sql: string): Promise<QueryResult>;