ldr 0.0.0-alpha.1 → 0.2.0

package/dist/model.d.ts

@@ -0,0 +1,44 @@
+import { parse, norm, type Doc, type M } from "./spec.js";
+/** A placed part. `color` is an LDraw colour code (or direct colour 0x2RRGGBB); `m` is the 12-number LDraw matrix `x y z a b c d e f g h i`. */
+export interface PartInstance {
+    part: string;
+    color: number;
+    m: M;
+    /** Build step of the top-level model this instance appears in (0-based). */
+    step: number;
+    /** Step path through nested submodels, e.g. [3, 1] = top step 3, submodel step 1. */
+    steps: number[];
+    /** Submodel path, e.g. "main.ldr/wheel.ldr". */
+    path: string;
+}
+export interface FlattenOptions {
+    /** Resolve an external reference that is not a submodel of this document (e.g. a model file you loaded separately). Return null to treat it as a part. */
+    resolveModel?: (name: string) => Doc | null;
+    /** Max submodel nesting (cycle guard). Default 64. */
+    maxDepth?: number;
+}
+/** Flatten a parsed LDraw document into part instances. Submodels (`0 FILE` blocks in an MPD) are expanded; everything else is treated as a part. */
+export declare function flatten(doc: Doc, opts?: FlattenOptions): PartInstance[];
+/** Parse LDraw text (.ldr/.mpd/.dat) and flatten it in one call. */
+export declare function parseModel(text: string, name?: string, opts?: FlattenOptions): PartInstance[];
+/**
+ * Assign each instance a global sequential build-step index, ordering by the full nested step path
+ * (so submodel steps become their own steps). Returns the number of steps.
+ */
+export declare function sequenceSteps<T extends {
+    steps: number[];
+}>(insts: T[]): {
+    count: number;
+    stepOf: Int32Array;
+};
+/** Colour table entry. */
+export interface LDrawColor {
+    code: number;
+    name: string;
+    hex: string;
+    edge: string;
+    alpha: number;
+}
+/** Parse LDConfig.ldr (or any file with `!COLOUR` lines) into a code → colour map. */
+export declare function parseLDConfig(text: string): Map<number, LDrawColor>;
+export { parse, norm };

package/dist/node/build-pack.d.ts

@@ -0,0 +1,29 @@
+export interface BuildPackOptions {
+    /** Root of an LDraw library (folder containing LDConfig.ldr, parts/, p/). Get it from https://library.ldraw.org (complete.zip). */
+    ldrawRoot: string;
+    /** Model files (.ldr/.mpd) or raw model text whose parts should be included. */
+    models?: (string | {
+        name: string;
+        text: string;
+    })[];
+    /** Extra part references to include, e.g. ["3001.dat"]. */
+    parts?: string[];
+    /** Include every part in parts/ (large: the full library is ~20k parts). */
+    allParts?: boolean;
+    /** Stud geometry: 'low' uses p/8 low-res primitives (default, ~visually lossless at distance); 'full' keeps full detail. */
+    studs?: "low" | "full";
+    /** Non-stud primitive detail. Default 'full'. */
+    primitives?: "low" | "full";
+    /** Weld + index vertices (smaller GPU buffers, faster). Default true. */
+    weld?: boolean;
+    /** Embed the LDConfig colour table (code → hex) in the pack header. Default true. */
+    colors?: boolean;
+    onProgress?: (done: number, total: number) => void;
+}
+export interface BuildPackResult {
+    data: Uint8Array;
+    parts: number;
+    studKinds: number;
+    missing: string[];
+}
+export declare function buildPack(o: BuildPackOptions): BuildPackResult;

package/dist/node/compile.d.ts

@@ -0,0 +1,43 @@
+import { Library } from './resolver.js';
+export type Opts = {
+    studs: 'full' | 'low';
+    prims: 'full' | 'low';
+    weld: boolean;
+    separateStuds: boolean;
+};
+export type Bucket = {
+    pos: number[];
+    col: number[];
+};
+export type Compiled = {
+    body: Bucket;
+    under: Bucket;
+    edges: number[];
+    condLines: number;
+    studs: {
+        kind: string;
+        color: string;
+        m: number[];
+    }[];
+    bbox: number[];
+    fullBottom: boolean;
+    uncertified?: boolean;
+    bottomMask?: {
+        nx: number;
+        nz: number;
+        bits: number[];
+    };
+};
+export declare function loadColors(root: string): Map<string, number[]>;
+export declare class Compiler {
+    lib: Library;
+    opts: Opts;
+    colors: Map<string, number[]>;
+    cache: Map<string, Compiled>;
+    constructor(lib: Library, opts: Opts);
+    resolve(ref: string, isStud: boolean): string | null;
+    compile(key: string, separateStuds?: boolean): Compiled;
+}
+export declare function writePack(file: string, parts: Map<string, Compiled>, studKinds: Map<string, Compiled>, weld: boolean, extra?: Record<string, unknown>): void;
+/** Serialize compiled parts into the binary pack format read by `decodePack`/`loadPack`. `extra` keys are merged into the JSON header (e.g. `colors`). */
+export declare function encodePack(parts: Map<string, Compiled>, studKinds: Map<string, Compiled>, weld: boolean, extra?: Record<string, unknown>): Uint8Array;

package/dist/node/index.d.ts

@@ -0,0 +1,7 @@
+export * from "../index.js";
+export { Library } from "./library.js";
+export { buildPack } from "./build-pack.js";
+export type { BuildPackOptions, BuildPackResult } from "./build-pack.js";
+export { Compiler, encodePack, writePack, loadColors } from "./compile.js";
+export type { Compiled, Opts as CompileOptions, Bucket } from "./compile.js";
+export { Library as ResolverLibrary, splitModel, flatten as flattenWithLibrary, collectDeps } from "./resolver.js";