@miclivs/cadcli 0.1.0

package/dist/core/overview.js

@@ -0,0 +1,227 @@
+import { loadDrawing } from "./drawing.js";
+const DEFAULT_KEYWORDS = 8;
+const DEFAULT_SAMPLES = 8;
+const MAX_LAYER_TYPES = 6;
+const STOP_WORDS = new Set([
+    "the",
+    "and",
+    "for",
+    "with",
+    "from",
+    "this",
+    "that",
+    "are",
+    "was",
+    "were",
+    "floor",
+    "plan",
+    "drawing",
+]);
+function stringifyValue(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (["string", "number", "boolean", "bigint"].includes(typeof value)) {
+        return String(value);
+    }
+    if (Array.isArray(value))
+        return value.map(stringifyValue).join(" ");
+    if (typeof value === "object") {
+        return Object.values(value)
+            .map(stringifyValue)
+            .join(" ");
+    }
+    return "";
+}
+function cleanText(text) {
+    return text
+        .replace(/https?:\/\/[^\s)>\]]+/g, " ")
+        .replace(/\b[a-f0-9]{8,}\b/gi, " ")
+        .replace(/[_-]+/g, " ");
+}
+function tokens(text) {
+    return (cleanText(text)
+        .toLowerCase()
+        .match(/[\p{L}\p{N}]{2,}/gu) ?? [])
+        .filter((term) => !STOP_WORDS.has(term))
+        .filter((term) => !/^\d+$/.test(term));
+}
+function terms(text) {
+    const words = tokens(text);
+    const result = [...words];
+    for (let index = 0; index < words.length - 1; index++) {
+        const left = words[index];
+        const right = words[index + 1];
+        if (left !== right)
+            result.push(`${left} ${right}`);
+    }
+    return result;
+}
+function addTerms(freq, text, weight) {
+    for (const term of terms(text)) {
+        freq.set(term, (freq.get(term) ?? 0) + weight);
+    }
+}
+function topTerms(freq, limit) {
+    const selected = [];
+    const suppressed = new Set();
+    const sorted = [...freq.entries()].sort((a, b) => b[1] - a[1]);
+    for (const [term] of sorted) {
+        if (selected.length >= limit)
+            break;
+        if (suppressed.has(term))
+            continue;
+        if (term.includes(" ") && (freq.get(term) ?? 0) < 2)
+            continue;
+        selected.push(term);
+        if (term.includes(" ")) {
+            for (const part of term.split(" "))
+                suppressed.add(part);
+        }
+    }
+    return selected;
+}
+function dataText(entity) {
+    return [
+        entity.id,
+        entity.type,
+        entity.layer ?? "",
+        String(entity.data.text ?? ""),
+        String(entity.data.value ?? ""),
+        String(entity.data.name ?? ""),
+        String(entity.data.blockName ?? ""),
+        String(entity.data.block_name ?? ""),
+        stringifyValue(entity.data),
+    ].join(" ");
+}
+function visibleText(entity) {
+    const text = entity.data.text ?? entity.data.value ?? entity.data.Text;
+    if (text === undefined || text === null)
+        return undefined;
+    const trimmed = String(text).trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function blockName(entity) {
+    const value = entity.data.blockName ?? entity.data.block_name ?? entity.data.name;
+    if (value === undefined || value === null)
+        return undefined;
+    const name = String(value).trim();
+    return name.length > 0 ? name : undefined;
+}
+function frequencyBy(values) {
+    const counts = new Map();
+    for (const value of values) {
+        if (!value)
+            continue;
+        counts.set(value, (counts.get(value) ?? 0) + 1);
+    }
+    return counts;
+}
+function sortedCounts(counts) {
+    return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
+}
+function layerKeywords(entities, documentFrequency, totalLayers, maxKeywords) {
+    const weighted = entities.map((entity) => ({
+        text: dataText(entity),
+        weight: entity.type === "TEXT" || entity.type === "MTEXT" ? 3 : 1,
+    }));
+    const freq = new Map();
+    for (const source of weighted)
+        addTerms(freq, source.text, source.weight);
+    const scored = new Map();
+    for (const [term, tf] of freq) {
+        const idf = Math.log(1 + totalLayers / (documentFrequency.get(term) ?? 1));
+        scored.set(term, tf * idf);
+    }
+    return topTerms(scored, maxKeywords);
+}
+function buildDocumentFrequency(layerEntities) {
+    const df = new Map();
+    for (const entities of layerEntities.values()) {
+        const seen = new Set();
+        for (const entity of entities) {
+            for (const term of terms(dataText(entity)))
+                seen.add(term);
+        }
+        for (const term of seen)
+            df.set(term, (df.get(term) ?? 0) + 1);
+    }
+    return df;
+}
+function uniquePush(items, value, limit) {
+    if (!value || items.length >= limit || items.includes(value))
+        return;
+    items.push(value);
+}
+export function createDrawingOverview(doc, opts = {}) {
+    const maxKeywords = opts.keywords ?? DEFAULT_KEYWORDS;
+    const maxSamples = opts.samples ?? DEFAULT_SAMPLES;
+    const layerEntities = new Map();
+    for (const layer of doc.layers)
+        layerEntities.set(layer.name, []);
+    for (const entity of doc.entities) {
+        const layer = entity.layer ?? "(no layer)";
+        if (!layerEntities.has(layer))
+            layerEntities.set(layer, []);
+        layerEntities.get(layer)?.push(entity);
+    }
+    const documentFrequency = buildDocumentFrequency(layerEntities);
+    const totalLayers = Math.max(layerEntities.size, 1);
+    const layers = [...layerEntities.entries()].map(([name, entities]) => {
+        const typeCounts = sortedCounts(frequencyBy(entities.map((e) => e.type)));
+        return {
+            name,
+            entities: entities.length,
+            types: typeCounts.slice(0, MAX_LAYER_TYPES).map(([type]) => type),
+            keywords: layerKeywords(entities, documentFrequency, totalLayers, maxKeywords),
+        };
+    });
+    layers.sort((a, b) => b.entities - a.entities || a.name.localeCompare(b.name));
+    const entityTypes = sortedCounts(frequencyBy(doc.entities.map((e) => e.type))).map(([type, count]) => ({ type, count }));
+    const references = frequencyBy(doc.entities.map(blockName));
+    const definitionCounts = frequencyBy(doc.blocks.map((block) => block.name));
+    const blockNames = new Set([
+        ...references.keys(),
+        ...definitionCounts.keys(),
+    ]);
+    const blocks = [...blockNames]
+        .map((name) => ({
+        name,
+        definitions: definitionCounts.get(name) ?? 0,
+        references: references.get(name) ?? 0,
+    }))
+        .sort((a, b) => b.references - a.references ||
+        b.definitions - a.definitions ||
+        a.name.localeCompare(b.name));
+    const textFreq = new Map();
+    const textSamples = [];
+    for (const entity of doc.entities) {
+        const text = visibleText(entity);
+        if (!text)
+            continue;
+        uniquePush(textSamples, text, maxSamples);
+        addTerms(textFreq, text, 1);
+    }
+    const searchHints = [];
+    for (const term of topTerms(textFreq, maxKeywords))
+        uniquePush(searchHints, term, maxKeywords);
+    for (const layer of layers)
+        uniquePush(searchHints, layer.name, maxKeywords);
+    for (const block of blocks)
+        uniquePush(searchHints, block.name, maxKeywords);
+    for (const type of entityTypes)
+        uniquePush(searchHints, type.type, maxKeywords);
+    return {
+        summary: doc.summary,
+        layers,
+        entityTypes,
+        blocks,
+        text: {
+            keywords: topTerms(textFreq, maxKeywords),
+            samples: textSamples,
+        },
+        searchHints,
+    };
+}
+export async function getOverview(file, opts = {}, loadOpts = {}) {
+    return createDrawingOverview(await loadDrawing(file, loadOpts), opts);
+}

package/dist/core/search-cache.d.ts

@@ -0,0 +1,17 @@
+export interface CachedSearchDoc {
+    id: number;
+    entityId: string;
+    type: string;
+    layer?: string;
+    text: string;
+    entity: unknown;
+}
+export interface SearchCacheData {
+    version: number;
+    fingerprint: string;
+    index: string;
+    docs: CachedSearchDoc[];
+}
+export declare function computeDrawingFingerprint(file: string): string;
+export declare function loadSearchCache(file: string, fingerprint: string, cacheDir?: string): SearchCacheData | null;
+export declare function saveSearchCache(file: string, data: Omit<SearchCacheData, "version">, cacheDir?: string): void;

package/dist/core/search-cache.js

@@ -0,0 +1,69 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { getCacheDir } from "../store.js";
+import { stringifyJson } from "../utils/output.js";
+const CACHE_VERSION = 1;
+export function computeDrawingFingerprint(file) {
+    const stat = statSync(file);
+    return createHash("sha1")
+        .update(`${resolve(file)}:${stat.size}:${stat.mtimeMs}`)
+        .digest("hex");
+}
+function cacheFileFor(file, cacheDir) {
+    const root = cacheDir ?? getCacheDir();
+    const key = createHash("sha1").update(resolve(file)).digest("hex");
+    return join(root, "search", `${basename(file)}-${key}.search.json`);
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object";
+}
+function isCachedSearchDoc(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.id === "number" &&
+        typeof value.entityId === "string" &&
+        typeof value.type === "string" &&
+        (value.layer === undefined || typeof value.layer === "string") &&
+        typeof value.text === "string" &&
+        value.entity !== undefined);
+}
+function parseSearchCache(value) {
+    if (!isRecord(value))
+        return null;
+    if (value.version !== CACHE_VERSION)
+        return null;
+    if (typeof value.fingerprint !== "string")
+        return null;
+    if (typeof value.index !== "string")
+        return null;
+    if (!Array.isArray(value.docs))
+        return null;
+    if (!value.docs.every(isCachedSearchDoc))
+        return null;
+    return {
+        version: CACHE_VERSION,
+        fingerprint: value.fingerprint,
+        index: value.index,
+        docs: value.docs,
+    };
+}
+export function loadSearchCache(file, fingerprint, cacheDir) {
+    const cachePath = cacheFileFor(file, cacheDir);
+    if (!existsSync(cachePath))
+        return null;
+    try {
+        const data = parseSearchCache(JSON.parse(readFileSync(cachePath, "utf-8")));
+        if (!data || data.fingerprint !== fingerprint)
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export function saveSearchCache(file, data, cacheDir) {
+    const cachePath = cacheFileFor(file, cacheDir);
+    mkdirSync(dirname(cachePath), { recursive: true });
+    writeFileSync(cachePath, stringifyJson({ version: CACHE_VERSION, ...data }));
+}

package/dist/core/search.d.ts

@@ -0,0 +1,18 @@
+import type { DwgEntity, EntityFilter } from "../types.js";
+import { type LoadOptions } from "./drawing.js";
+export interface DwgSearchOptions extends EntityFilter {
+    query?: string;
+    limit?: number;
+    score?: boolean;
+    snippets?: boolean;
+    cacheDir?: string;
+}
+export interface DwgSearchResult {
+    entityId: string;
+    type: string;
+    layer?: string;
+    score: number;
+    matches: string[];
+    entity: DwgEntity;
+}
+export declare function searchDrawing(file: string, opts?: DwgSearchOptions, loadOpts?: LoadOptions): Promise<DwgSearchResult[]>;

package/dist/core/search.js

@@ -0,0 +1,137 @@
+import MiniSearch from "minisearch";
+import { loadDrawing } from "./drawing.js";
+import { computeDrawingFingerprint, loadSearchCache, saveSearchCache, } from "./search-cache.js";
+const SEARCH_FIELDS = ["entityId", "type", "layer", "text"];
+const STORE_FIELDS = ["entityId", "type", "layer", "text"];
+const DEFAULT_LIMIT = 30;
+const MAX_MATCHES = 5;
+function createSearchIndex() {
+    return new MiniSearch({
+        fields: [...SEARCH_FIELDS],
+        storeFields: [...STORE_FIELDS],
+        searchOptions: {
+            boost: { entityId: 3, type: 2, layer: 2, text: 1 },
+            fuzzy: 0.2,
+            prefix: true,
+        },
+    });
+}
+function loadSearchIndex(indexJson) {
+    return MiniSearch.loadJSON(indexJson, {
+        fields: [...SEARCH_FIELDS],
+        storeFields: [...STORE_FIELDS],
+        searchOptions: {
+            boost: { entityId: 3, type: 2, layer: 2, text: 1 },
+            fuzzy: 0.2,
+            prefix: true,
+        },
+    });
+}
+function stringifyValue(value) {
+    if (value === null || value === undefined)
+        return "";
+    if (["string", "number", "boolean", "bigint"].includes(typeof value)) {
+        return String(value);
+    }
+    if (Array.isArray(value))
+        return value.map(stringifyValue).join(" ");
+    if (typeof value === "object") {
+        return Object.entries(value)
+            .map(([key, val]) => `${key} ${stringifyValue(val)}`)
+            .join(" ");
+    }
+    return "";
+}
+function textFields(entity) {
+    const values = [
+        entity.id,
+        entity.type,
+        entity.layer ?? "",
+        String(entity.data.text ?? ""),
+        String(entity.data.value ?? ""),
+        String(entity.data.name ?? ""),
+        String(entity.data.blockName ?? ""),
+        String(entity.data.block_name ?? ""),
+        stringifyValue(entity.data),
+    ];
+    return values.filter((value) => value.trim().length > 0);
+}
+function buildDocs(doc) {
+    return doc.entities.map((entity, id) => ({
+        id,
+        entityId: entity.id,
+        type: entity.type,
+        layer: entity.layer,
+        text: textFields(entity).join(" "),
+        entity,
+    }));
+}
+function buildIndex(docs) {
+    const index = createSearchIndex();
+    index.addAll(docs);
+    return index;
+}
+function matchesFilter(doc, opts) {
+    if (opts.type && doc.type.toLowerCase() !== opts.type.toLowerCase()) {
+        return false;
+    }
+    if (opts.layer && doc.layer?.toLowerCase() !== opts.layer.toLowerCase()) {
+        return false;
+    }
+    return true;
+}
+function matchesFor(doc, query) {
+    if (!query)
+        return [];
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (terms.length === 0)
+        return [];
+    return textFields(doc.entity)
+        .filter((chunk) => {
+        const lower = chunk.toLowerCase();
+        return terms.some((term) => lower.includes(term));
+    })
+        .slice(0, MAX_MATCHES);
+}
+async function loadSearchCorpus(file, opts, loadOpts) {
+    const fingerprint = computeDrawingFingerprint(file);
+    const cached = loadSearchCache(file, fingerprint, opts.cacheDir);
+    if (cached) {
+        return {
+            docs: cached.docs,
+            index: loadSearchIndex(cached.index),
+        };
+    }
+    const docs = buildDocs(await loadDrawing(file, loadOpts));
+    const index = buildIndex(docs);
+    saveSearchCache(file, { fingerprint, index: JSON.stringify(index), docs }, opts.cacheDir);
+    return { docs, index };
+}
+function resultScore(result) {
+    return Math.round((Number(result.score) || 1) * 10) / 10;
+}
+export async function searchDrawing(file, opts = {}, loadOpts = {}) {
+    const { docs, index } = await loadSearchCorpus(file, opts, loadOpts);
+    const query = opts.query?.trim();
+    const byId = new Map(docs.map((doc) => [doc.id, doc]));
+    const raw = query
+        ? index.search(query).map((result) => ({
+            id: Number(result.id),
+            score: result.score,
+        }))
+        : docs.map((doc) => ({ id: doc.id, score: 1 }));
+    return raw
+        .map((result) => ({ result, doc: byId.get(result.id) }))
+        .filter((item) => Boolean(item.doc))
+        .filter(({ doc }) => matchesFilter(doc, opts))
+        .map(({ result, doc }) => ({
+        entityId: doc.entityId,
+        type: doc.type,
+        layer: doc.layer,
+        score: resultScore(result),
+        matches: opts.snippets === false ? [] : matchesFor(doc, query),
+        entity: doc.entity,
+    }))
+        .sort((a, b) => b.score - a.score)
+        .slice(0, opts.limit ?? DEFAULT_LIMIT);
+}

package/dist/core/svg.d.ts

@@ -0,0 +1,2 @@
+import type { DwgDocument, SvgResult } from "../types.js";
+export declare function renderSvg(doc: DwgDocument): SvgResult;

package/dist/core/svg.js

@@ -0,0 +1,105 @@
+const DEFAULT_BOUNDS = { minX: 0, minY: 0, maxX: 100, maxY: 100 };
+function data(entity) {
+    return entity.data;
+}
+function record(value) {
+    return value && typeof value === "object"
+        ? value
+        : {};
+}
+function point(value) {
+    const obj = record(value);
+    const x = Number(obj.x ?? obj.X ?? obj[0]);
+    const y = Number(obj.y ?? obj.Y ?? obj[1]);
+    return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null;
+}
+function number(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+}
+function escapeXml(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;");
+}
+function y(value) {
+    return -value;
+}
+function renderLine(entity) {
+    const rec = data(entity);
+    const start = point(rec.start ?? rec.startPoint);
+    const end = point(rec.end ?? rec.endPoint);
+    if (!start || !end)
+        return null;
+    return `<line x1="${start.x}" y1="${y(start.y)}" x2="${end.x}" y2="${y(end.y)}" />`;
+}
+function renderCircle(entity) {
+    const rec = data(entity);
+    const center = point(rec.center);
+    const radius = number(rec.radius ?? rec.r);
+    if (!center || radius === null)
+        return null;
+    return `<circle cx="${center.x}" cy="${y(center.y)}" r="${radius}" />`;
+}
+function renderPolyline(entity) {
+    const vertices = Array.isArray(entity.data.vertices)
+        ? entity.data.vertices.map(point).filter((p) => p !== null)
+        : [];
+    if (vertices.length === 0)
+        return null;
+    return `<polyline points="${vertices.map((p) => `${p.x},${y(p.y)}`).join(" ")}" />`;
+}
+function renderText(entity) {
+    const rec = data(entity);
+    const position = point(rec.position ?? rec.insertionPoint ?? rec.start);
+    if (!position)
+        return null;
+    const text = escapeXml(String(rec.text ?? rec.value ?? ""));
+    return `<text x="${position.x}" y="${y(position.y)}">${text}</text>`;
+}
+const RENDERERS = {
+    LINE: renderLine,
+    CIRCLE: renderCircle,
+    LWPOLYLINE: renderPolyline,
+    POLYLINE: renderPolyline,
+    TEXT: renderText,
+    MTEXT: renderText,
+};
+function rendererFor(entity) {
+    return RENDERERS[entity.type];
+}
+function boundsFor(doc) {
+    return doc.summary.bounds ?? DEFAULT_BOUNDS;
+}
+function viewBox(bounds) {
+    const width = Math.max(1, bounds.maxX - bounds.minX || DEFAULT_BOUNDS.maxX);
+    const height = Math.max(1, bounds.maxY - bounds.minY || DEFAULT_BOUNDS.maxY);
+    return `${bounds.minX} ${y(bounds.maxY)} ${width} ${height}`;
+}
+function metadata(unsupported, rendered) {
+    return escapeXml(JSON.stringify({ unsupported, rendered }));
+}
+export function renderSvg(doc) {
+    const bounds = boundsFor(doc);
+    const elements = [];
+    let unsupported = 0;
+    for (const entity of doc.entities) {
+        const renderer = rendererFor(entity);
+        const element = renderer?.(entity) ?? null;
+        if (element)
+            elements.push(element);
+        else
+            unsupported++;
+    }
+    const rendered = elements.length;
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="${viewBox(bounds)}">
+  <g fill="none" stroke="currentColor" stroke-width="1">
+    ${elements.join("\n    ")}
+  </g>
+  <metadata>${metadata(unsupported, rendered)}</metadata>
+</svg>
+`;
+    return { svg, unsupported, rendered, bounds };
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export type { LibreDwgEditResult, LibreDwgJsonResult, LibreDwgViewResult, } from "./core/libredwg.js";
+export type { DrawingOverview, DrawingOverviewOptions, OverviewBlock, OverviewEntityType, OverviewLayer, OverviewText, } from "./core/overview.js";
+export type { DwgSearchOptions, DwgSearchResult } from "./core/search.js";
+export { Dwg } from "./sdk.js";
+export type { DwgBlock, DwgBounds, DwgDocument, DwgEntity, DwgFormat, DwgLayer, DwgSummary, EntityFilter, SvgResult, ThumbnailResult, } from "./types.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { Dwg } from "./sdk.js";

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};