@mylasertools/kerfscript 0.0.0-stage → 0.2.1

package/dist/customizer.d.cts

@@ -0,0 +1,19 @@
+import type { Value } from './values.cjs';
+export interface Parameter {
+    name: string;
+    caption: string;
+    group: string;
+    type: 'number' | 'string' | 'boolean';
+    initial: Value;
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: {
+        name: string;
+        value: number | string;
+    }[];
+    span: [number, number];
+}
+export declare function parameters(source: string): {
+    parameters: Parameter[];
+};

package/dist/customizer.d.ts

@@ -0,0 +1,19 @@
+import type { Value } from './values.js';
+export interface Parameter {
+    name: string;
+    caption: string;
+    group: string;
+    type: 'number' | 'string' | 'boolean';
+    initial: Value;
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: {
+        name: string;
+        value: number | string;
+    }[];
+    span: [number, number];
+}
+export declare function parameters(source: string): {
+    parameters: Parameter[];
+};

package/dist/evaluator.d.cts

@@ -0,0 +1,129 @@
+import type { Expr, Param, Program, Stmt } from './ast.cjs';
+import { type Shape } from './geometry.cjs';
+import { type Pos } from './lexer.cjs';
+import { type FontBook } from './text.cjs';
+import { type Closure, type Value } from './values.cjs';
+export interface LayerDef {
+    name: string;
+    mode: 'cut' | 'line' | 'fill' | 'guide';
+    color: string;
+}
+export declare const DEFAULT_LAYERS: LayerDef[];
+export interface EvalOptions {
+    overrides?: Record<string, Value>;
+    resolve?: (path: string) => string | undefined;
+    fonts?: FontBook;
+    maxSteps?: number;
+    limits?: Partial<Limits>;
+}
+export interface Limits {
+    maxParts: number;
+    maxSegments: number;
+    maxListLength: number;
+    maxListItems: number;
+    maxTextLength: number;
+    maxPoints: number;
+    maxOutputPoints: number;
+    maxSheets: number;
+}
+export declare const DEFAULT_LIMITS: Limits;
+interface ModDef {
+    params: Param[];
+    body: Stmt[];
+    env: Env;
+}
+interface FnDef {
+    params: Param[];
+    body: Expr;
+    env: Env;
+}
+interface ChildCtx {
+    stmts: Stmt[];
+    env: Env;
+}
+declare class Env {
+    parent?: Env | undefined;
+    caller?: Env | undefined;
+    vars: Map<string, Value>;
+    fns: Map<string, FnDef>;
+    mods: Map<string, ModDef>;
+    children?: ChildCtx;
+    constructor(parent?: Env | undefined, caller?: Env | undefined);
+    get(name: string): {
+        found: boolean;
+        value?: Value;
+    };
+    fn(name: string): FnDef | undefined;
+    mod(name: string): ModDef | undefined;
+    childCtx(): ChildCtx | undefined;
+}
+interface Args {
+    pos: Value[];
+    named: Map<string, Value>;
+    at: Pos;
+}
+export interface EvalResult {
+    shape: Shape;
+    globals: Env;
+    layers: Map<string, LayerDef>;
+    echoes: string[];
+    warnings: string[];
+}
+export declare const STDLIB: Record<string, string>;
+export declare class Evaluator {
+    private opts;
+    private steps;
+    private depth;
+    private maxSteps;
+    readonly limits: Limits;
+    private pointCount;
+    private itemCount;
+    private copies;
+    readonly echoes: string[];
+    readonly warnings: string[];
+    readonly layers: Map<string, LayerDef>;
+    private loaded;
+    private builtins;
+    constructor(opts?: EvalOptions);
+    run(program: Program): EvalResult;
+    private tick;
+    private load;
+    private hoist;
+    private included;
+    private assign;
+    block(stmts: Stmt[], env: Env, top?: boolean): Shape;
+    private stmt;
+    private bindSeq;
+    private iterable;
+    private loop;
+    private evalArgs;
+    private bindParams;
+    private callModule;
+    private childStmts;
+    callFunction(f: FnDef | Closure, args: Args, caller: Env, name: string): Value;
+    expr(x: Expr, env: Env): Value;
+    private listItem;
+    private grow;
+    private charge;
+    private call;
+    private specialFunction;
+    private echo;
+    private echoText;
+    private arith;
+    private arg;
+    private num;
+    private vec2;
+    private points;
+    private dyn;
+    private spend;
+    private checkValue;
+    private checkSize;
+    private segs;
+    private thickness;
+    private fingerWidth;
+    private measure;
+    private textOpts;
+    private edges;
+    private makeBuiltins;
+}
+export {};

package/dist/evaluator.d.ts

@@ -0,0 +1,129 @@
+import type { Expr, Param, Program, Stmt } from './ast.js';
+import { type Shape } from './geometry.js';
+import { type Pos } from './lexer.js';
+import { type FontBook } from './text.js';
+import { type Closure, type Value } from './values.js';
+export interface LayerDef {
+    name: string;
+    mode: 'cut' | 'line' | 'fill' | 'guide';
+    color: string;
+}
+export declare const DEFAULT_LAYERS: LayerDef[];
+export interface EvalOptions {
+    overrides?: Record<string, Value>;
+    resolve?: (path: string) => string | undefined;
+    fonts?: FontBook;
+    maxSteps?: number;
+    limits?: Partial<Limits>;
+}
+export interface Limits {
+    maxParts: number;
+    maxSegments: number;
+    maxListLength: number;
+    maxListItems: number;
+    maxTextLength: number;
+    maxPoints: number;
+    maxOutputPoints: number;
+    maxSheets: number;
+}
+export declare const DEFAULT_LIMITS: Limits;
+interface ModDef {
+    params: Param[];
+    body: Stmt[];
+    env: Env;
+}
+interface FnDef {
+    params: Param[];
+    body: Expr;
+    env: Env;
+}
+interface ChildCtx {
+    stmts: Stmt[];
+    env: Env;
+}
+declare class Env {
+    parent?: Env | undefined;
+    caller?: Env | undefined;
+    vars: Map<string, Value>;
+    fns: Map<string, FnDef>;
+    mods: Map<string, ModDef>;
+    children?: ChildCtx;
+    constructor(parent?: Env | undefined, caller?: Env | undefined);
+    get(name: string): {
+        found: boolean;
+        value?: Value;
+    };
+    fn(name: string): FnDef | undefined;
+    mod(name: string): ModDef | undefined;
+    childCtx(): ChildCtx | undefined;
+}
+interface Args {
+    pos: Value[];
+    named: Map<string, Value>;
+    at: Pos;
+}
+export interface EvalResult {
+    shape: Shape;
+    globals: Env;
+    layers: Map<string, LayerDef>;
+    echoes: string[];
+    warnings: string[];
+}
+export declare const STDLIB: Record<string, string>;
+export declare class Evaluator {
+    private opts;
+    private steps;
+    private depth;
+    private maxSteps;
+    readonly limits: Limits;
+    private pointCount;
+    private itemCount;
+    private copies;
+    readonly echoes: string[];
+    readonly warnings: string[];
+    readonly layers: Map<string, LayerDef>;
+    private loaded;
+    private builtins;
+    constructor(opts?: EvalOptions);
+    run(program: Program): EvalResult;
+    private tick;
+    private load;
+    private hoist;
+    private included;
+    private assign;
+    block(stmts: Stmt[], env: Env, top?: boolean): Shape;
+    private stmt;
+    private bindSeq;
+    private iterable;
+    private loop;
+    private evalArgs;
+    private bindParams;
+    private callModule;
+    private childStmts;
+    callFunction(f: FnDef | Closure, args: Args, caller: Env, name: string): Value;
+    expr(x: Expr, env: Env): Value;
+    private listItem;
+    private grow;
+    private charge;
+    private call;
+    private specialFunction;
+    private echo;
+    private echoText;
+    private arith;
+    private arg;
+    private num;
+    private vec2;
+    private points;
+    private dyn;
+    private spend;
+    private checkValue;
+    private checkSize;
+    private segs;
+    private thickness;
+    private fingerWidth;
+    private measure;
+    private textOpts;
+    private edges;
+    private makeBuiltins;
+}
+export {};

package/dist/export/dxf.d.cts

@@ -0,0 +1,3 @@
+import type { LayerDef } from '../evaluator.cjs';
+import type { Placed } from '../render.cjs';
+export declare function toDxf(items: Placed[], _width: number, height: number, layers: LayerDef[]): string;

package/dist/export/dxf.d.ts

@@ -0,0 +1,3 @@
+import type { LayerDef } from '../evaluator.js';
+import type { Placed } from '../render.js';
+export declare function toDxf(items: Placed[], _width: number, height: number, layers: LayerDef[]): string;

package/dist/export/svg.d.cts

@@ -0,0 +1,15 @@
+import type { LayerDef } from '../evaluator.cjs';
+import { type Poly } from '../geometry.cjs';
+import type { Placed } from '../render.cjs';
+export declare const n: (v: number) => string;
+export declare function tidy(p: Poly, closed: boolean): [string, string][];
+export interface LayerPath {
+    name: string;
+    mode: LayerDef['mode'];
+    color: string;
+    d: string;
+    regions: string;
+    lines: string;
+}
+export declare function layerPaths(items: Placed[], layers: LayerDef[]): LayerPath[];
+export declare function toSvg(items: Placed[], width: number, height: number, layers: LayerDef[]): string;

package/dist/export/svg.d.ts

@@ -0,0 +1,15 @@
+import type { LayerDef } from '../evaluator.js';
+import { type Poly } from '../geometry.js';
+import type { Placed } from '../render.js';
+export declare const n: (v: number) => string;
+export declare function tidy(p: Poly, closed: boolean): [string, string][];
+export interface LayerPath {
+    name: string;
+    mode: LayerDef['mode'];
+    color: string;
+    d: string;
+    regions: string;
+    lines: string;
+}
+export declare function layerPaths(items: Placed[], layers: LayerDef[]): LayerPath[];
+export declare function toSvg(items: Placed[], width: number, height: number, layers: LayerDef[]): string;

package/dist/functions.d.cts

@@ -0,0 +1,4 @@
+import { type Value } from './values.cjs';
+type Fn = (args: Value[], named: Map<string, Value>) => Value;
+export declare const FUNCTIONS: Record<string, Fn>;
+export {};

package/dist/functions.d.ts

@@ -0,0 +1,4 @@
+import { type Value } from './values.js';
+type Fn = (args: Value[], named: Map<string, Value>) => Value;
+export declare const FUNCTIONS: Record<string, Fn>;
+export {};

package/dist/geometry.d.cts

@@ -0,0 +1,44 @@
+export type Pt = [number, number];
+export type Poly = Pt[];
+export type Matrix = [number, number, number, number, number, number];
+export interface Layer {
+    regions: Poly[];
+    lines: Poly[];
+}
+export interface PartShape {
+    name: string;
+    qty: number;
+    layers: Map<string, Layer>;
+    thickness: number;
+    kerf: number;
+    material: string;
+}
+export interface Shape {
+    layers: Map<string, Layer>;
+    parts: PartShape[];
+}
+export declare const IDENTITY: Matrix;
+export declare function emptyShape(): Shape;
+export declare function regionShape(regions: Poly[], layer?: string): Shape;
+export declare function lineShape(lines: Poly[], layer?: string): Shape;
+export declare function isEmpty(s: Shape): boolean;
+export declare function union(regions: Poly[], fill?: 'nonzero' | 'evenodd'): Poly[];
+export declare const difference: (a: Poly[], b: Poly[]) => Poly[];
+export declare const intersection: (a: Poly[], b: Poly[]) => Poly[];
+export declare const xor: (a: Poly[], b: Poly[]) => Poly[];
+export declare function clipLines(lines: Poly[], region: Poly[], keep: 'inside' | 'outside'): Poly[];
+export declare function offset(regions: Poly[], delta: number, join?: 'round' | 'miter' | 'square', arcTolerance?: number): Poly[];
+export declare function strokeLines(lines: Poly[], width: number): Poly[];
+export declare function pieces(regions: Poly[]): Poly[][];
+export declare function area(p: Poly): number;
+export declare function multiply(m: Matrix, n: Matrix): Matrix;
+export declare function apply(m: Matrix, [x, y]: Pt): Pt;
+export declare function transform(s: Shape, m: Matrix): Shape;
+export declare function merge(shapes: Shape[]): Shape;
+export declare function retag(s: Shape, layer: string): Shape;
+export declare function bounds(polys: Poly[]): [number, number, number, number] | null;
+export declare function layerBounds(layers: Map<string, Layer>, skip?: (name: string) => boolean): [number, number, number, number] | null;
+export declare function hull(points: Pt[]): Poly;
+export declare function fragments(r: number, fn: number, fa: number, fs: number): number;
+export declare function ellipsePoly(rx: number, ry: number, n: number): Poly;
+export declare function roundedRect(w: number, h: number, r: number, segs: (r: number) => number): Poly;

package/dist/geometry.d.ts

@@ -0,0 +1,44 @@
+export type Pt = [number, number];
+export type Poly = Pt[];
+export type Matrix = [number, number, number, number, number, number];
+export interface Layer {
+    regions: Poly[];
+    lines: Poly[];
+}
+export interface PartShape {
+    name: string;
+    qty: number;
+    layers: Map<string, Layer>;
+    thickness: number;
+    kerf: number;
+    material: string;
+}
+export interface Shape {
+    layers: Map<string, Layer>;
+    parts: PartShape[];
+}
+export declare const IDENTITY: Matrix;
+export declare function emptyShape(): Shape;
+export declare function regionShape(regions: Poly[], layer?: string): Shape;
+export declare function lineShape(lines: Poly[], layer?: string): Shape;
+export declare function isEmpty(s: Shape): boolean;
+export declare function union(regions: Poly[], fill?: 'nonzero' | 'evenodd'): Poly[];
+export declare const difference: (a: Poly[], b: Poly[]) => Poly[];
+export declare const intersection: (a: Poly[], b: Poly[]) => Poly[];
+export declare const xor: (a: Poly[], b: Poly[]) => Poly[];
+export declare function clipLines(lines: Poly[], region: Poly[], keep: 'inside' | 'outside'): Poly[];
+export declare function offset(regions: Poly[], delta: number, join?: 'round' | 'miter' | 'square', arcTolerance?: number): Poly[];
+export declare function strokeLines(lines: Poly[], width: number): Poly[];
+export declare function pieces(regions: Poly[]): Poly[][];
+export declare function area(p: Poly): number;
+export declare function multiply(m: Matrix, n: Matrix): Matrix;
+export declare function apply(m: Matrix, [x, y]: Pt): Pt;
+export declare function transform(s: Shape, m: Matrix): Shape;
+export declare function merge(shapes: Shape[]): Shape;
+export declare function retag(s: Shape, layer: string): Shape;
+export declare function bounds(polys: Poly[]): [number, number, number, number] | null;
+export declare function layerBounds(layers: Map<string, Layer>, skip?: (name: string) => boolean): [number, number, number, number] | null;
+export declare function hull(points: Pt[]): Poly;
+export declare function fragments(r: number, fn: number, fa: number, fs: number): number;
+export declare function ellipsePoly(rx: number, ry: number, n: number): Poly;
+export declare function roundedRect(w: number, h: number, r: number, segs: (r: number) => number): Poly;