circuit-json-to-gerber 0.0.1 → 0.0.3

package/README.md

@@ -5,7 +5,7 @@ Some components of this gerber system:
 - A JSON command representation (defined in part with zod), all gerber command
   definitions are in [./commands](./commands)
   - Each command features a stringification function
-- A function that converts soup to the Gerber commands [./convert-soup-to-gerber-commands](./convert-soup-to-gerber-commands)
+- A function that converts soup to the Gerber commands [./src/convert-soup-to-gerber-commands](./convert-soup-to-gerber-commands)
 
 ## References
 

package/dist/index.d.ts

@@ -0,0 +1,343 @@
+import { AnyZodObject, z } from 'zod';
+import { AnySoupElement } from '@tscircuit/soup';
+
+interface GerberCommandDef<K extends string, T extends AnyZodObject | z.ZodIntersection<any, any>> {
+    command_code: K;
+    schema: T;
+    stringify: (c: z.infer<T>) => string;
+}
+
+declare const gerber_command_map: {
+    readonly add_attribute_on_aperture: GerberCommandDef<"TA", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"TA">>;
+        attribute_name: z.ZodString;
+        attribute_value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "TA";
+        attribute_name: string;
+        attribute_value: string;
+    }, {
+        attribute_name: string;
+        attribute_value: string;
+        command_code?: "TA" | undefined;
+    }>>;
+    readonly add_attribute_on_file: GerberCommandDef<"TF", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"TF">>;
+        attribute_name: z.ZodString;
+        attribute_value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "TF";
+        attribute_name: string;
+        attribute_value: string;
+    }, {
+        attribute_name: string;
+        attribute_value: string;
+        command_code?: "TF" | undefined;
+    }>>;
+    readonly add_attribute_on_object: GerberCommandDef<"TO", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"TO">>;
+        attribute_name: z.ZodString;
+        attribute_value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "TO";
+        attribute_name: string;
+        attribute_value: string;
+    }, {
+        attribute_name: string;
+        attribute_value: string;
+        command_code?: "TO" | undefined;
+    }>>;
+    readonly aperture_block: GerberCommandDef<"AB", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"AB">>;
+        block: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "AB";
+        block: string;
+    }, {
+        block: string;
+        command_code?: "AB" | undefined;
+    }>>;
+    readonly comment: GerberCommandDef<"G04", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G04">>;
+        comment: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G04";
+        comment: string;
+    }, {
+        comment: string;
+        command_code?: "G04" | undefined;
+    }>>;
+    readonly create_arc: GerberCommandDef<"G75", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G75">>;
+        arc_parameters: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G75";
+        arc_parameters: string;
+    }, {
+        arc_parameters: string;
+        command_code?: "G75" | undefined;
+    }>>;
+    readonly define_aperture: GerberCommandDef<"AD", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"AD">>;
+        aperture_code: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "AD";
+        aperture_code: string;
+    }, {
+        aperture_code: string;
+        command_code?: "AD" | undefined;
+    }>>;
+    readonly define_macro_aperture_template: GerberCommandDef<"AM", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"AM">>;
+        macro_name: z.ZodString;
+        template_code: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "AM";
+        macro_name: string;
+        template_code: string;
+    }, {
+        macro_name: string;
+        template_code: string;
+        command_code?: "AM" | undefined;
+    }>>;
+    readonly delete_attribute: GerberCommandDef<"TD", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"TD">>;
+        attribute: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "TD";
+        attribute?: string | undefined;
+    }, {
+        command_code?: "TD" | undefined;
+        attribute?: string | undefined;
+    }>>;
+    readonly end_of_file: GerberCommandDef<"M02", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"M02">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "M02";
+    }, {
+        command_code?: "M02" | undefined;
+    }>>;
+    readonly move_operation: GerberCommandDef<"D02", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"D02">>;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "D02";
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+        command_code?: "D02" | undefined;
+    }>>;
+    readonly flash_operation: GerberCommandDef<"D03", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"D03">>;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "D03";
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+        command_code?: "D03" | undefined;
+    }>>;
+    readonly format_specification: GerberCommandDef<"FS", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"FS">>;
+        zero_omission_mode: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodLiteral<"L">, z.ZodLiteral<"T">]>>>;
+        coordinate_notation: z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"A">, z.ZodLiteral<"I">]>>;
+        x_integer_digits: z.ZodDefault<z.ZodNumber>;
+        x_decimal_digits: z.ZodDefault<z.ZodNumber>;
+        y_integer_digits: z.ZodDefault<z.ZodNumber>;
+        y_decimal_digits: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "FS";
+        zero_omission_mode: "L" | "T" | null;
+        coordinate_notation: "A" | "I";
+        x_integer_digits: number;
+        x_decimal_digits: number;
+        y_integer_digits: number;
+        y_decimal_digits: number;
+    }, {
+        command_code?: "FS" | undefined;
+        zero_omission_mode?: "L" | "T" | null | undefined;
+        coordinate_notation?: "A" | "I" | undefined;
+        x_integer_digits?: number | undefined;
+        x_decimal_digits?: number | undefined;
+        y_integer_digits?: number | undefined;
+        y_decimal_digits?: number | undefined;
+    }>>;
+    readonly plot_operation: GerberCommandDef<"D01", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"D01">>;
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "D01";
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+        command_code?: "D01" | undefined;
+    }>>;
+    readonly define_aperture_template: GerberCommandDef<"ADD", z.ZodIntersection<z.ZodDiscriminatedUnion<"standard_template_code", [z.ZodObject<{
+        standard_template_code: z.ZodLiteral<"C">;
+        diameter: z.ZodNumber;
+        hole_diameter: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        standard_template_code: "C";
+        diameter: number;
+        hole_diameter?: number | undefined;
+    }, {
+        standard_template_code: "C";
+        diameter: number;
+        hole_diameter?: number | undefined;
+    }>, z.ZodObject<{
+        standard_template_code: z.ZodLiteral<"R">;
+        x_size: z.ZodNumber;
+        y_size: z.ZodNumber;
+        hole_diameter: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        standard_template_code: "R";
+        x_size: number;
+        y_size: number;
+        hole_diameter?: number | undefined;
+    }, {
+        standard_template_code: "R";
+        x_size: number;
+        y_size: number;
+        hole_diameter?: number | undefined;
+    }>, z.ZodObject<{
+        standard_template_code: z.ZodLiteral<"O">;
+        x_size: z.ZodNumber;
+        y_size: z.ZodNumber;
+        hole_diameter: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        standard_template_code: "O";
+        x_size: number;
+        y_size: number;
+        hole_diameter?: number | undefined;
+    }, {
+        standard_template_code: "O";
+        x_size: number;
+        y_size: number;
+        hole_diameter?: number | undefined;
+    }>, z.ZodObject<{
+        standard_template_code: z.ZodLiteral<"P">;
+        outer_diameter: z.ZodNumber;
+        number_of_vertices: z.ZodNumber;
+        rotation: z.ZodOptional<z.ZodNumber>;
+        hole_diameter: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        standard_template_code: "P";
+        outer_diameter: number;
+        number_of_vertices: number;
+        rotation?: number | undefined;
+        hole_diameter?: number | undefined;
+    }, {
+        standard_template_code: "P";
+        outer_diameter: number;
+        number_of_vertices: number;
+        rotation?: number | undefined;
+        hole_diameter?: number | undefined;
+    }>]>, z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"ADD">>;
+        aperture_number: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "ADD";
+        aperture_number: number;
+    }, {
+        aperture_number: number;
+        command_code?: "ADD" | undefined;
+    }>>>;
+    readonly set_movement_mode_to_clockwise_circular: GerberCommandDef<"G02", z.ZodObject<{
+        command_code: z.ZodLiteral<"G02">;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G02";
+    }, {
+        command_code: "G02";
+    }>>;
+    readonly set_movement_mode_to_counterclockwise_circular: GerberCommandDef<"G03", z.ZodObject<{
+        command_code: z.ZodLiteral<"G03">;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G03";
+    }, {
+        command_code: "G03";
+    }>>;
+    readonly set_movement_mode_to_linear: GerberCommandDef<"G01", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"G01">>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "G01";
+    }, {
+        command_code?: "G01" | undefined;
+    }>>;
+    readonly select_aperture: GerberCommandDef<"D", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"D">>;
+        aperture_number: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "D";
+        aperture_number: number;
+    }, {
+        aperture_number: number;
+        command_code?: "D" | undefined;
+    }>>;
+    readonly set_unit: GerberCommandDef<"MO", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"MO">>;
+        unit: z.ZodEnum<["mm", "in"]>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "MO";
+        unit: "mm" | "in";
+    }, {
+        unit: "mm" | "in";
+        command_code?: "MO" | undefined;
+    }>>;
+    readonly set_layer_polarity: GerberCommandDef<"LP", z.ZodObject<{
+        command_code: z.ZodDefault<z.ZodLiteral<"LP">>;
+        polarity: z.ZodEnum<["D", "C"]>;
+    }, "strip", z.ZodTypeAny, {
+        command_code: "LP";
+        polarity: "D" | "C";
+    }, {
+        polarity: "D" | "C";
+        command_code?: "LP" | undefined;
+    }>>;
+};
+type AnyGerberCommand = z.infer<(typeof gerber_command_map)[keyof typeof gerber_command_map]["schema"]>;
+
+declare const gerberBuilder: () => GerberBuilder;
+declare class GerberBuilder {
+    commands: Array<AnyGerberCommand>;
+    constructor();
+    $if(condition: boolean, fn: (gb: GerberBuilder) => GerberBuilder): GerberBuilder;
+    add<T extends keyof typeof gerber_command_map>(cmd: T, props: z.input<(typeof gerber_command_map)[T]["schema"]>): GerberBuilder;
+    build(): Array<AnyGerberCommand>;
+}
+
+type LayerToGerberCommandsMap = {
+    F_Cu: AnyGerberCommand[];
+    F_SilkScreen: AnyGerberCommand[];
+    F_Mask: AnyGerberCommand[];
+    F_Paste: AnyGerberCommand[];
+    B_Cu: AnyGerberCommand[];
+    B_SilkScreen: AnyGerberCommand[];
+    B_Mask: AnyGerberCommand[];
+    B_Paste: AnyGerberCommand[];
+    Edge_Cuts: AnyGerberCommand[];
+};
+type GerberLayerName = keyof LayerToGerberCommandsMap;
+
+declare const stringifyGerberCommandLayers: (commandLayers: Record<GerberLayerName, AnyGerberCommand[]>) => Record<GerberLayerName, string>;
+
+declare const stringifyGerberCommand: (command: AnyGerberCommand) => string;
+
+declare const stringifyGerberCommands: (commands: AnyGerberCommand[]) => string;
+
+/**
+ * Converts tscircuit soup to arrays of Gerber commands for each layer
+ */
+declare const convertSoupToGerberCommands: (soup: AnySoupElement[], opts?: {
+    flip_y_axis?: boolean;
+}) => LayerToGerberCommandsMap;
+
+export { convertSoupToGerberCommands, gerberBuilder, stringifyGerberCommand, stringifyGerberCommandLayers, stringifyGerberCommands };