feat:提交

Reviewed-on: #16
Co-authored-by: lixiang <504331699@qq.com>
Co-committed-by: lixiang <504331699@qq.com>

.vscode/launch.json

@@ -0,0 +1,36 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+      {
+        "type": "node",
+        "request": "launch",
+        "name": "Jest All",
+        "program": "${workspaceFolder}/node_modules/.bin/jest",
+        "args": ["--runInBand"],
+        "console": "integratedTerminal",
+        "internalConsoleOptions": "neverOpen",
+        "disableOptimisticBPs": true,
+        "windows": {
+          "program": "${workspaceFolder}/node_modules/jest/bin/jest"
+        }
+      },
+      {
+        "type": "node",
+        "request": "launch",
+        "name": "Jest Current File",
+        "program": "${workspaceFolder}/node_modules/.bin/jest",
+        "args": [
+          "--runTestsByPath",
+          "${relativeFile}",
+          "--config",
+          "jest.config.js"
+        ],
+        "console": "integratedTerminal",
+        "internalConsoleOptions": "neverOpen",
+        "disableOptimisticBPs": true,
+        "windows": {
+          "program": "${workspaceFolder}/node_modules/jest/bin/jest"
+        }
+      }
+    ]
+  }

README.md

@@ -0,0 +1,152 @@
+# Cut Abstractions
+
+这是一个用于MES新版生产的抽象库，提供了一套可扩展的处理器和解析器，用于处理各种切割相关的指令和数据。
+
+## 核心概念
+
+- **处理器 (Processor)**: 负责执行具体的加工任务。每个处理器都包含名称、版本和执行方法。开发者可以继承 `ProcessorBase` 来实现自定义的处理器。
+
+- **解析器 (Parser)**: 负责解析文本指令，并调用相应的处理代码。`ParserBase` 提供了解析和执行指令的基本框架。
+
+- **上下文 (Context)**: 在处理器执行期间传递数据，包含输入、参数和输出。
+
+## 主要功能
+
+- **可扩展的处理器架构**: 允许开发者轻松添加新的加工处理器，以适应不同的业务需求。
+- **灵活的指令解析**: 支持自定义指令集，可以解析文本格式的指令并执行相应的操作。
+- **清晰的数据流**: 通过上下文对象在处理器之间传递数据，使得数据流清晰可控。
+
+## 使用示例
+
+以下是一个简单的示例，展示了如何使用本库：
+
+```typescript
+import { ProcessorBase, ProcessorContext } from 'cut-abstractions';
+
+// 定义输入、输出和配置类型
+interface MyInput {
+  data: string;
+}
+
+interface MyOutput {
+  result: string;
+}
+
+interface MyConfig {
+  param: string;
+}
+
+// 创建一个自定义处理器
+class MyProcessor extends ProcessorBase<MyInput, MyOutput, MyConfig> {
+  get name() {
+    return 'my-processor';
+  }
+
+  get version() {
+    return '1.0.0';
+  }
+
+  exec(context: ProcessorContext<MyInput, MyOutput, MyConfig>) {
+    // 执行处理逻辑
+    const inputData = context.input?.data || '';
+    const param = context.params?.param || '';
+    context.output = {
+      result: `Processed: ${inputData} with param: ${param}`,
+    };
+  }
+}
+
+// 使用处理器
+const processor = new MyProcessor();
+const context: ProcessorContext<MyInput, MyOutput, MyConfig> = {
+  input: { data: 'hello' },
+  params: { param: 'world' },
+};
+
+processor.exec(context);
+
+console.log(context.output?.result); // "Processed: hello with param: world"
+```
+
+## 模块
+
+- `base`: 提供了处理器的基本抽象。
+- `parsers`: 提供了指令解析器的基本抽象。
+- `models`: 定义了项目中使用的数据模型，如 `Config`、`Knife` 和 `File`。
+
+## 术语表
+
+| 中文 | CAD | MES | IMES  | 备注 |
+| --- | --- | --- | --- | --- |
+| 房名 | RoomName | roomName | roomName | |
+| 柜名 | CabinetName | boxName | bodyName | |
+| 小板名 | BoardName | blockName | blockName | |
+| 材质 | Material | material | material | |
+| 大板名 | 无 | boardName | goodsName | |
+| 余料 | 无 | scrap | remain | |
+| 排单 | 无 | planOrder |planOrder | |
+
+## 编译与发布  
+
+更新 package.json 版本号  
+
+```shell  
+pnpm clean  
+pnpm build  
+pnpm release  
+```
+
+## 开发
+
+### 处理器类型
+
+处理器的上下文类型应当提交至该项目以方便协作，包括处理器输入，输出以及配置类型。  
+这些类型应当定义在`src/models/processors/<处理器名>.ts`文件中。
+例：
+
+```ts
+// src/models/processors/rectLayout.ts
+
+// 矩形优化处理器类型
+
+export interface RectLayoutProcInput {
+  blocks: Array<RectLayoutBlock>
+}
+export type RectLayoutProcOutput = never;
+export class RectLayoutProcConfig extends ConfigBase {}
+
+export interface RectLayoutBlock {}
+
+```
+
+定义类型时请遵循以下约定：
+
+- 处理器的输入/输出/配置类型(以下称为*相关类型*)请按照特定规则进行命名，其大小写应当遵循[PascalCase](https://pascal-case.com/)：
+  - 输入类型: `<处理器名>Input`
+  - 输出类型: `<处理器名>Output`
+  - 配置类型: `<处理器名>Config`
+- 处理器的配置类型必须为一个Javascript类，并继承自抽象类`ConfigBase`，输入和输出类型不限。
+- 处理器相关类型的字段若涉及到附属类型，也一并定义在文件中，其命名不限，但必须与处理器的名字有所关联，不易于其它处理器混淆，例：
+
+  ```ts
+  export interface RectLayoutProcInput {
+    blocks: Array<RectLayoutBlock> // 附属类型
+  }
+  // 同样定义在该文件中，
+  export interface RectLayoutBlock {}
+  ```
+
+- 若处理器相关类型中出现了唯一标识符，请统一使用`string | number`作为Typescript类型，例：
+
+  ```ts
+  export interface RectLayoutBlock {
+    id: string | number; // 使用string | number类型作为唯一标识符  
+  }
+  ```
+
+- 若处理器相关类型中出现了平面尺寸相关的，请使用“长(`length`)/宽(`width`)”作为其名称，请勿使用“宽(`width`)/高(`height`)”。
+  
+  > [!Warning]
+  > “长”指的是一个矩形板件在**横轴**上的尺寸，而“宽”指的是**纵轴**上的尺寸。
+  > 
+  > 在旧版生产的数据中，“长/宽”与“宽/高”是混用的，在矩形优化后，原有板件的“长(l)”变为了“高(pbg)”，而“宽(w)”变为了“宽(pbk)”，因为矩形优化涉及到了坐标转换，后续还需要对规范进行统一。

jest.config.js

@@ -2,5 +2,7 @@ module.exports = {
   transform: {
     '^.+\\.(t|j)sx?$': '@swc/jest',
   },
+  preset: 'ts-jest',
+  testEnvironment: 'node',
   extensionsToTreatAsEsm: ['.ts', '.tsx']
 };

package.json

@@ -1,16 +1,20 @@
 {
   "name": "cut-abstractions",
-  "version": "0.1.1",
+  "version": "0.3.4",
   "description": "",
-  "main": "index.ts",
-  "files": ["dist/**/*"],
+  "files": [
+    "dist/**/*"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.js",
   "exports": {
-    ".": "./dist/**/*"
+    ".": "./dist/index.js"
   },
   "scripts": {
     "build": "tsc",
     "release": "pnpm pack --pack-destination ./dist-packs",
-    "clean":"rimraf ./dist",
+    "clean": "rimraf ./dist",
     "test": "jest"
   },
   "keywords": [],
@@ -21,6 +25,8 @@
     "@jest/globals": "^30.0.2",
     "@swc/core": "^1.12.4",
     "@swc/jest": "^0.2.38",
+    "@types/jest": "^30.0.0",
+    "cadapi": "http://gitea.cf/MES-FE/webcad-api/archive/0.0.60.tar.gz",
     "jest": "^30.0.2",
     "rimraf": "^6.0.1",
     "typescript": "^5.8.3"

samples/confClass.ts

@@ -1,348 +0,0 @@
-
-
-
-/** 内部指令 接收 */
-export class CodeAction {
-    code?: String
-    order?: String
-    codeParams?: any
-}
-/**内部响应类 */
-export class GCodeResType {
-    code: number = -1
-    data: any = null
-    msg: string = ''
-    logError(msg) {
-        console.error(msg)
-    }
-}
-
-
-// 加工项 点数据 
-export class CodeParams {
-    /** x坐标 */
-    x?: Number | String
-    /** y坐标 */
-    y?: Number | String
-    /** z坐标 */
-    z?: Number | String
-    /** 调用的代码编号 */
-    dir?: Number | String
-    /** 圆弧半径 */
-    r?: Number | String
-    /** 速度  */
-    f?: Number | String
-    /** IJK 模式的i */
-    i?: Number | String
-    /** IJK 模式的j */
-    j?: Number | String
-    /** IJK 模式的k */
-    k?: Number | String
-
-    /** 代码标识 */
-    codeKey?: String
-    /** x坐标 */
-    xKey?: String
-    /** y坐标 */
-    yKey?: String
-    /** z坐标 */
-    zKey?: String
-    /** 圆弧半径 */
-    rKey?: String
-    /** 速度  */
-    fKey?: String
-    /** IJK 模式的i */
-    iKey?: String
-    /** IJK 模式的j */
-    jKey?: String
-    /** IJK 模式的k */
-    kKey?: String
-}
-
-
-export type _knifeType =  Partial<Knife>
-
-/**
- * 板面类型
- * 0正面 1反面 2侧面 21左侧面 22右侧面 23上侧面 24下侧面 29 弧形侧面 30异形侧面
- */
-export enum FaceType {
-    /** 正面 */
-    FRONT = 0,
-    /** 反面 */
-    BACK = 1,
-    /** 侧面 */
-    SIDE = 2,
-    /** 左侧面 */
-    LEFT_SIDE = 21,
-    /** 右侧面 */
-    RIGHT_SIDE = 22,
-    /** 上侧面 */
-    TOP_SIDE = 23,
-    /** 下侧面 */
-    BOTTOM_SIDE = 24,
-    /** 弧形侧面 */
-    CURVED_SIDE = 29,
-    /** 异形侧面 */
-    SPECIAL_SHAPED_SIDE = 30,
-}
-
-/** 开料刀 */
-export class Knife {
-    /** 是否启用 */
-    isEnabled = true;
-    /** 轴号 */
-    axleId = 0;
-    /** 开料刀ID号 */
-    knifeId = 1;
-    /** 加工面(0正面 1反面 2左侧面 3右侧面 4上侧面 5下侧面 6任意) */
-    processFace = 0;
-    /** 刀名称 */
-    knifeName = '';
-    /** 刀具类型(1铣刀 2成型刀 3钻头 4锯 5刀片) */
-    knifeType = KnifeType.MILLING_CUTTER;
-    /** 功能属性(数组): 1开料/切割 2拉槽 3铣型 4铣孔 5钻孔 6拉米诺 7乐扣 8T型 */
-    ability: any = [];
-
-    // /** 默认开料刀 */
-    // isDefaultCutKnife = false;
-    // /** 是否可用于开料切割 */
-    // isCuttingKnife = false;
-    // /** 是否允许铣孔(knifeType为铣刀生效) */
-    // isMillingAllowed = false;
-    /** 刀直径mm */
-    diameter = 6;
-    /** 刀长(最大深度) */
-    length = 20;
-    /** 锯齿厚度，单次加工切缝宽度 */
-    sawThiness = 0;
-    /**锯向: 0横向（或长边） 1纵向（短边） 2自由角度*/
-    sawDirection = 0;
-    /**切向加工方向: 0横向左往右 2横向右往左 3纵向上往下 4纵向下往上 5随意 */
-    processDirection = 0;
-    /**进给速度, 0取系统默认 */
-    speed = 0;
-    /** 进给深度 */
-    stepDepth = 0;
-    // /** 组号 */
-    // groupNo = 0;
-    // /** 主刀 */
-    // isMainKnife = false;
-    // /** 是否高级加工 */
-    // isAdvancedProcessEnabled = false;
-    // /** 是否集合加工 */
-    // isBatchProcessEnabled = false;
-    // /** 副刀偏置长边偏移(Y轴) */
-    // auxKnifeOffsetY = 0;
-    // /** 副刀偏置短边偏移(X轴) */
-    // auxKnifeOffsetX = 0;
-    /** 偏置短边偏移(X轴)-相对于工件原点位置XY坐标的短边方向偏移量 */
-    offsetX = 0;
-    /** 偏置长边偏移(Y轴) -相对于工件原点位置XY坐标的长边方向偏移量*/
-    offsetY = 0;
-    /** 偏置垂直偏移(Z轴) -相对于工件原点位置XY坐标的垂直方向偏移量*/
-    offsetZ = 0;
-    /** 基准坐标-短边(X轴) -钻头在钻包中短边方向(纵向)的相对位置 */
-    baseX = 0;
-    /** 基准坐标-长边(Y轴) -钻头在钻包中长边方向(横向)的相对位置 */
-    baseY = 0;
-    /**组合钻 */
-    isModularDrill = false;
-    /** 是否预启动 */
-    isPreStartEnabled = false;
-    /** 预启动提前动作数 */
-    preStartAheadActionCount = 5;
-    /** 预启动延迟换刀 */
-    isPreStartToolChangeDelay = false;
-    /** 预启动延迟换刀指令 */
-    preStartToolChangeDelayCode = '';
-    /** 轴启动指令后置 */
-    isAxisStartCodePostpost = false;
-    /** 轴停止指令前置 */
-    isAxisStopCodePrepose = false;
-    /** 钻组独立指令（启用后，刀起始指令、刀结束指令使用钻组起始指令、钻组结束指令替换） */
-    drillGroupCode = '';
-
-    /** 轴启动代码*/
-    axisStartCode = "";
-    /** 刀启动代码 */
-    knifeStartCode = '';
-    /** 钻组起始指令 */
-    drillGroupStartCode = '';
-    /** 钻组结束指令 */
-    drillGroupEndCode = '';
-    /** 刀停止代码 */
-    knifeStopCode = '';
-    /** 轴停止指令 */
-    axisStopCode = '';
-    // /** 高级加工指令 */
-    // advancedCode = '';
-
-
-    /** 设置刀具(轴号, 刀名, 刀直径, 是否主刀, 是否铣孔, 是否开料刀) */
-    // set(axleId: number, name: string, diameter: number, isMainKnife: boolean, isMillingAllowed: boolean, isCuttingKnife: boolean)
-    /** 设置刀具(轴号, 刀名, 刀类型, 刀直径, 刀长, 是否默认刀) */
-}
-
-
-/** 刀类型: MILLING_CUTTER铣刀 FORMING_CUTTER成型刀 DRILL钻头 SAW锯 BLADE刀片 */
-export enum KnifeType {
-    /** 铣刀 */
-    MILLING_CUTTER = 1,
-    /** 成型刀 */
-    FORMING_CUTTER = 2,
-    /** 钻头 */
-    DRILL = 3,
-    /** 锯 */
-    SAW = 4,
-    /** 刀片 */
-    BLADE = 5
-}
-
-/** 刀功能: 
- ** 1-CUT开料/切割 2-PULLING_GROOVE拉槽 3-MILLING_MODEL铣型 4-MILLING_HOLE铣孔 
- ** 5-DRILL_HOLE钻孔 6-RAMINO拉米诺 7-EASY_FASTEN乐扣 8-T_TYPE T型 */
-export enum AbilityType {
-    /** 1开料/切割 */
-    CUT = 1,
-    /** 2拉槽 */
-    PULLING_GROOVE = 2,
-    /** 3铣型 */
-    MILLING_MODEL = 3,
-    /** 4铣孔 */
-    MILLING_HOLE = 4,
-    /** 5钻孔 */
-    DRILL_HOLE = 5,
-    /** 6拉米诺 */
-    RAMINO = 6,
-    /** 7乐扣 */
-    EASY_FASTEN = 7,
-    /** 8T型 */
-    T_TYPE = 8
-}
-
-/** 枚举 坐标轴类型 */
-export enum AxisType {
-    /** X轴正 */
-    X_POS = 0,
-    /** X轴负 */
-    X_NEG = 1,
-    /** Y轴正 */
-    Y_POS = 2,
-    /** Y轴负 */
-    Y_NEG = 3,
-    /** 向上Z轴正 */
-    Z_POS = 4,
-    /** 向下Z轴负 */
-    Z_NEG = 5,
-}
-
-/** 枚举 坐标轴类型 */
-export enum OriginZPosition {
-    /** 台面向上Z轴正 */
-    WorkTop = 0,
-    /** 板面向上Z轴正 */
-    BoardFace = 1,
-}
-
-// nc文件编码
-export const ncEncodeMap = {
-    'UTF-8': 'UTF-8',
-    'GB2312': 'GB2312',
-    'UTF-8-BOM': 'UTF-8-BOM',
-    'GBK': 'GBK',
-    'Big-5': 'Big-5',
-    'GB18030': 'GB18030',
-    'Unicode': 'Unicode'
-}
-
-// 小板文件名选项
-export const smallPlateOptionsMap = {
-    板宽: '{0}',
-    板长: '{1}',
-    颜色: '{2}',
-    材质: '{3}',
-    大板号: '{4}',
-    工位号: '{5}',
-    板厚: '{6}',
-    开料顺序: '{7}',
-    批次识别: '{8}',
-    小板编号: '{9}',
-    全局大板号: '{10}',
-    品牌: '{11}',
-}
-
-// zip压缩包文件名选项
-export const zipFileOptionsMap = {
-    '板宽': '{0}',
-    '板长': '{1}',
-    '颜色': '{2}',
-    '材质': '{3}',
-    '大板号': '{4}',
-    '工位号': '{5}',
-    '板厚': '{6}',
-    '开料顺序': '{7}',
-    '批次识别': '{8}',
-    '小板编号': '{9}',
-    '全局大板号': '{10}',
-    '品牌': '11',
-}
-
-/** 枚举 大板边角位置 */
-export enum BoardPosition {
-    /** 左上角 */
-    // LEFT_TOP = 0,
-    // /** 左下角 */
-    // LEFT_BOTTOM = 1,
-    // /** 右下角 */
-    // RIGHT_BOTTOM = 2,
-    // /** 右上角 */
-    // RIGHT_TOP = 3,
-    /** 左上角 */
-    LEFT_TOP = 3,
-    /** 左下角 */
-    LEFT_BOTTOM = 0,
-    /** 右下角 */
-    RIGHT_BOTTOM = 1,
-    /** 右上角 */
-    RIGHT_TOP = 2,
-    /**
-     *     左下角 = 0,
-      右下角 = 1,
-      右上角 = 2,
-      左上角 = 3
-     */
-}
-
-/** 排版样式 */
-export enum PlaceStyle {
-    /** 正面 */
-    FRONT = 0,
-    /** 正面右转 */
-    FRONT_TURN_RIGHT = 1,
-    /** 正面后转 */
-    FRONT_TURN_BACK = 2,
-    /** 正面左转 */
-    FRONT_TURN_LEFT = 3,
-    /** 反面 */
-    BACK = 4,
-    /** 反面右转 */
-    BACK_TURN_RIGHT = 5,
-    /** 反面后转 */
-    BACK_TURN_BACK = 6,
-    /** 反面左转 */
-    BACK_TURN_LEFT = 7,
-}
-
-/** 小板边的位置类型 */
-export enum EdgeType
-  {
-  /** 下=0 */
-  BOTTOM = 0,
-  /** 右=1 */
-  RIGHT = 1,
-  /** 上=2 */
-  TOP = 2,
-  /** 左=3 */
-  LEFT = 3,
-}

samples/demoKnives.ts

@@ -1,112 +0,0 @@
-import { _knifeType } from "./confClass"
-
-/** demo  刀具数据 */
-export const knifeData :_knifeType= {
-    "isEnabled": true,
-    "axleId": 2,
-    "knifeId": 2,
-    "knifeName": "T1",
-    "knifeType": 3,
-    "ability": [
-        5
-    ],
-    "diameter": 5,
-    "length": 20,
-    "sawThiness": 7,
-    "sawDirection": 2,
-    "processDirection": 4,
-    "speed": 0,
-    "stepDepth": 0,
-    "offsetX": 0,
-    "offsetY": 0,
-    "offsetZ": 0,
-    "baseX": 0,
-    "baseY": 0,
-    "isModularDrill": false,
-    "isPreStartEnabled": false,
-    "preStartAheadActionCount": 5,
-    "isPreStartToolChangeDelay": false,
-    "preStartToolChangeDelayCode": "",
-    "isAxisStartCodePostpost": false,
-    "isAxisStopCodePrepose": false,
-    "drillGroupCode": "",
-    "axisStartCode": "M03 S18000\n",
-    "knifeStartCode": `M06 T1\nG43 H1\n`,
-    "drillGroupStartCode": "T1",
-    "drillGroupEndCode": "",
-    "knifeStopCode": "",
-    "axisStopCode": "M05\n",
-}
-export const knifeData1:_knifeType = {
-    "isEnabled": true,
-    "axleId": 2,
-    "knifeId": 2,
-    "knifeName": "T2",
-    "knifeType": 3,
-    "ability": [
-        5
-    ],
-    "diameter": 6,
-    "length": 20,
-    "sawThiness": 7,
-    "sawDirection": 2,
-    "processDirection": 4,
-    "speed": 0,
-    "stepDepth": 0,
-    "offsetX": 0,
-    "offsetY": 0,
-    "offsetZ": 0,
-    "baseX": 0,
-    "baseY": 0,
-    "isModularDrill": false,
-    "isPreStartEnabled": false,
-    "preStartAheadActionCount": 5,
-    "isPreStartToolChangeDelay": false,
-    "preStartToolChangeDelayCode": "",
-    "isAxisStartCodePostpost": false,
-    "isAxisStopCodePrepose": false,
-    "drillGroupCode": "",
-    "axisStartCode": "M03 S18000\n",
-    "knifeStartCode": `M06 T2\nG43 H2\n`,
-    "drillGroupStartCode": "T2",
-    "drillGroupEndCode": "",
-    "knifeStopCode": "",
-    "axisStopCode": "M05\n",
-}
-export const knifeData2:_knifeType = {
-    "isEnabled": true,
-    "axleId": 2,
-    "knifeId": 2,
-    "knifeName": "T3",
-    "knifeType": 3,
-    "ability": [
-        5
-    ],
-    "diameter": 6,
-    "length": 20,
-    "sawThiness": 7,
-    "sawDirection": 2,
-    "processDirection": 4,
-    "speed": 0,
-    "stepDepth": 0,
-    "offsetX": 0,
-    "offsetY": 0,
-    "offsetZ": 0,
-    "baseX": 0,
-    "baseY": 0,
-    "isModularDrill": false,
-    "isPreStartEnabled": false,
-    "preStartAheadActionCount": 5,
-    "isPreStartToolChangeDelay": false,
-    "preStartToolChangeDelayCode": "",
-    "isAxisStartCodePostpost": false,
-    "isAxisStopCodePrepose": false,
-    "drillGroupCode": "",
-
-    "axisStartCode": "M03 S18000\n",
-    "knifeStartCode": `M06 T2\nG43 H2\n`,
-    "drillGroupStartCode": "T3",
-    "drillGroupEndCode": "",
-    "knifeStopCode": "",
-    "axisStopCode": "M05\n",
-}

samples/demoParser.ts

@@ -1,124 +0,0 @@
-
-import { ConfigBase } from "../src/base";
-import { ParserBase } from "../src/parsers";
-import { _knifeType, CodeParams } from "./confClass";
-import { knifeData, knifeData1, knifeData2 } from "./demoKnives";
-import { GCodeAction } from "./gcodes";
-export class DemoParser extends ParserBase {
-    usedKnife?:_knifeType
-    knifeList:_knifeType[] = [
-        knifeData,
-        knifeData1,
-        knifeData2
-    ]
-    constructor(config?: Record<string, ConfigBase>) {
-        super();
-        // if(config){
-        //     if(config['knives']){
-        //         
-        //     }
-        // }
-        const gcodeActions = new GCodeAction();
-        this.codeManager['FSTART'] = {
-            name: 'FileStart',
-            // type:'Global',
-            // paramType:'array',
-            exec:(params) =>{
-                return `G54 G90\nM03\n`
-            }
-        };
-        this.codeManager['FEND'] = {
-            name: 'FileEnd',
-            exec:(params) =>{
-                return `M30\n`;
-            }
-        }
-        this.codeManager['G0'] = {
-            name: 'G0',
-            paramType: 'kv:number',
-            exec:(params: CodeParams) => {
-                return gcodeActions.G0(params) + '\n';
-            }
-        }
-        this.codeManager['G2'] = {
-            name: 'G2',
-            paramType: 'kv:number',
-            exec:(params: CodeParams)=> {
-                return gcodeActions.G2(params) + '\n';
-            }
-        }
-        this.codeManager['G3'] = {
-            name: 'G3',
-            paramType: 'kv:number',
-            exec:(params: CodeParams)=> {
-                return gcodeActions.G3(params) + '\n';
-            }
-        }
-        this.codeManager['TD'] = {
-            name: '',
-            exec:(diameter:number)=> {
-                    let code = ''
-                    let _knife: any
-
-                    if (diameter) {
-                        _knife = this.knifeList?.find(e => e.diameter == diameter)
-                    }
-
-
-                    if (_knife != undefined) {
-                        code += this.checkChangeKnife(_knife)
-                        this.usedKnife = _knife
-                        // code += _knife.axisStartCode
-                        code += _knife.knifeStartCode
-                    }
-                    return code
-                }
-        }
-        this.codeManager['TN'] = {
-            name: 'TN',
-            exec:(knifeName:string) =>{ /**根据刀名称找刀 换刀 */
-                let code = ''
-                let _knife: any = null
-                if (knifeName) {
-                    _knife = this.knifeList?.find(e => e.knifeName == knifeName)
-                }
-
-                if (_knife != undefined) {
-                    code += this.checkChangeKnife(_knife)
-                    this.usedKnife = _knife
-                    // code += _knife.axisStartCode
-                    code += _knife.knifeStartCode
-                }
-                return code
-            }
-        }
-        this.codeManager['TE'] = {
-            name:'TE',
-            exec:()=>{
-                if(!this.usedKnife) return '';
-                return this.usedKnife.knifeStopCode+'\n';
-            }
-        }
-    }
-
-    /** 内部功能逻辑  换刀时判断是否需要 上一把刀的停止代码 */
-    private checkChangeKnife(knife: _knifeType) {
-        let code = '';
-        /** true 需要 输出停刀代码  false 不需要 */
-        let flag = false
-        // 必须要有刀
-        if (this.usedKnife) {
-            let keys = Object.keys(knife)
-            for (const key of keys) {
-                if (knife[key] != this.usedKnife[key]) {
-                    flag = true
-                    continue
-                }
-            }
-        }
-        if (flag) {
-            code += this.exec('TE',[]);
-        }
-        return code;
-    }
-}

samples/gcodes.ts

@@ -1,528 +0,0 @@
-import { CodeParams } from "./confClass"
-
-function checkVal(val) {
-    let r = true
-    if ((val == undefined || val == '')) {
-        r = false
-    }
-    return r
-}
-
-/**G代码指令
- * 目前 只需要做 G0 - G3
- */
-export enum GCode {
-    /**快速定位 空程移动 范例：G00 X100 Y50（刀具快速移动至X100、Y50位置） */
-    G0 = 'G0',
-    /**快速定位 空程移动 范例：G00 X100 Y50（刀具快速移动至X100、Y50位置）*/
-    G00 = 'G00',
-    /**直线 直线插补 范例：G01 X200 Y300 F150（刀具以150mm/min的进给速度直线移动至X200、Y300）*/
-    G1 = 'G1',
-    /**直线 范例：G01 X200 Y300 F150（刀具以150mm/min的进给速度直线移动至X200、Y300）*/
-    G01 = 'G01',
-    /** 顺时针 范例：G17 G02 X150 Y50 I50 J0 F100（在XY平面，以半径50mm顺时针圆弧插补至X150、Y50）*/
-    G2 = 'G2',
-    /** 顺时针 范例：G17 G02 X150 Y50 I50 J0 F100（在XY平面，以半径50mm顺时针圆弧插补至X150、Y50）*/
-    G02 = 'G02',
-    /** 逆时针 范例：G17 G03 X150 Y50 I50 J0 F100（在XY平面，以半径50mm逆时针圆弧插补至X150、Y50）*/
-    G3 = 'G3',
-    /** 逆时针 范例：G17 G03 X150 Y50 I50 J0 F100（在XY平面，以半径50mm逆时针圆弧插补至X150、Y50）*/
-    G03 = 'G03',
-    /**暂停 范例：G04 X2（暂停2秒）*/
-    G4 = 'G4',
-    /**暂停 范例：G04 X2（暂停2秒）*/
-    G04 = 'G04',
-    /** 通过中间点圆弧插补 
-     * 1. 通过中间点圆弧插补
-     * 示例：G05 X60 Z50 IX50 IZ60 F120 刀具从当前位置出发，经过中间点 (50, 60)，最终到达终点 (60, 50)，形成圆弧轨迹。
-     * 2. 高精轨迹控制（HPCC）模式
-     * 功能：G05 可启动高精轨迹控制模式（HPCC），通过曲线拟合和参数优化，实现高精度、高速度的轨迹加工，适用于复杂曲面或高精度零件。
-     * 指令格式：
-     * 启动：G05 P10000（P值设为10000）
-     * 关闭：G05 P0（P值设为0）
-     * 3、注意事项：
-     * 轴类型限制：建议线性轴参与HPCC模式，旋转轴需谨慎设置。
-        与其他功能冲突：
-        在HPCC模式下，G61（准确停止检查）、G63（攻螺纹）等功能可能失效，需退出HPCC模式后恢复。
-        启用 RTCP（旋转刀具中心点）或 STCP 模式时，禁止同时启用HPCC功能。
-        不支持的功能：
-        不支持单节停止（C40/M00）、反向手轮模拟、图形模拟等。
-        剩余距离显示可能不准确，因显示的是离曲线终点的距离，而非单节终点。
-     * */
-    G5 = 'G5',
-    /** 通过中间点圆弧插补 */
-    G05 = 'G05',
-    /** 抛物线插补 */
-    G6 = 'G6',
-    /** 抛物线插补 */
-    G06 = 'G06',
-    /** z样条曲线插补 */
-    G7 = 'G7',
-    /** z样条曲线插补 */
-    G07 = 'G07',
-    /** 进给加速 */
-    G8 = 'G8',
-    /** 进给加速 */
-    G08 = 'G08',
-    /** 进给减速 */
-    G9 = 'G9',
-    /** 进给减速 */
-    G09 = 'G09',
-    /** 参数写入方式有效 */
-    G10 = 'G10',
-    /** 参数写入方式取消 */
-    G11 = 'G11',
-    /** 极坐标变成 */
-    G16 = 'G16',
-    /** XY平面选择 */
-    G17 = 'G17',
-    /** XZ平面选择 */
-    G18 = 'G18',
-    /** YZ平面选择 */
-    G19 = 'G19',
-    /** 英制输入 */
-    G20 = 'G20',
-    /** 公制输入 */
-    G21 = 'G21',
-    /** 半径尺寸编程方式  */
-    G22 = 'G22',
-    /** 系统操作界面上使用 */
-    G220 = 'G220',
-    /** 直径尺寸编程方式 */
-    G23 = 'G23',
-    /** 系统操作界面上使用  */
-    G230 = 'G230',
-    /** 子程序结束  */
-    G24 = 'G24',
-    /** 跳转加工  */
-    G25 = 'G25',
-    /** 循环加工 */
-    G26 = 'G26',
-    /** 参考点返回 */
-    G28 = 'G28',
-    /** 倍率注销 */
-    G30 = 'G30',
-    /** 倍率定义 */
-    G31 = 'G31',
-    /** 等螺距螺纹切削，英制 */
-    G32 = 'G32',
-    /** 等螺距螺纹切削，公制 */
-    G33 = 'G33',
-    /** 增螺距螺纹切削 */
-    G34 = 'G34',
-    /** 减螺距螺纹切削 */
-    G35 = 'G35',
-    //** 刀具半径补正取消 */
-    G40 = 'G40',
-    //** 刀具半径补正 左*/
-    G41 = 'G41',
-    //** 刀具半径补正 右*/
-    G42 = 'G42',
-    //** 刀具长度补正+ */
-    G43 = 'G43',
-    //** 刀具长度补正- */
-    G44 = 'G44',
-    //** 道具偏置+/+ */
-    G45 = 'G45',
-    //** 道具偏置+/- */
-    G46 = 'G46',
-    //** 道具偏置-/- */
-    G47 = 'G47',
-    //** 道具偏置-/+ */
-    G48 = 'G48',
-    //** 刀具长度 补正取消 */
-    G49 = 'G49',
-    //** 局部坐标系设定 */
-    G52 = 'G52',
-    //** 机床坐标系选择 */
-    G53 = 'G53',
-    //** 工件坐标系选择1 */
-    G54 = 'G54',
-    //** 工件坐标系选择2 */
-    G55 = 'G55',
-    //** 工件坐标系选择3 */
-    G56 = 'G56',
-    //** 工件坐标系选择4 */
-    G57 = 'G57',
-    //** 工件坐标系选择5 */
-    G58 = 'G58',
-    //** 工件坐标系选择6 */
-    G59 = 'G59',
-    //** 坐标系旋转有效 */
-    G68 = 'G68',
-    //** 坐标系旋转取消 */
-    G69 = 'G69',
-    /** 高速深孔钻 */
-    G73 = 'G73',
-    /** 精搪孔 */
-    G76 = 'G76',
-    /** 固定循环取消/取消循环指令 */
-    G80 = 'G80',
-    /**程序停止 */
-    M00 = 'M00',
-    /**选择性停止 */
-    M01 = 'M01',
-    /** 程序结束 */
-    M02 = 'M02',
-    /**主轴正转 */
-    M03 = 'M03',
-    /**主轴反转 */
-    M04 = 'M04',
-    /**主轴停止 */
-    M05 = 'M05',
-    /**自动换刀 */
-    M06 = 'M06',
-}
-
-/**G代码基类 */
-export class GCodeAction {
-
-    /** 空程直线 */
-    G0(params: CodeParams) {
-        const { x, y, z, f, xKey, yKey, zKey, fKey, codeKey } = params
-        let val: string = GCode.G0
-        if (typeof (codeKey) == 'string' && codeKey != '') {
-            val = codeKey
-        }
-        let _xkey = xKey || 'X'
-        let _yKey = yKey || 'Y'
-        let _zKey = zKey || 'Z'
-        let _fKey = fKey || 'F'
-        if (checkVal(x)) {
-            val += ` ${_xkey}${x}`
-        }
-        if (checkVal(y)) {
-            val += ` ${_yKey}${y}`
-        }
-        if (checkVal(z)) {
-            val += ` ${_zKey}${z}`
-        }
-        if (checkVal(f)) {
-            val += ` ${_fKey}${f}`
-        }
-        return val
-    }
-    /** 空程直线 */
-    G00(params: CodeParams) {
-        const { x, y, z, f, xKey, yKey, zKey, fKey, codeKey } = params
-        let val: string = GCode.G00
-        if (typeof (codeKey) == 'string' && codeKey != '') {
-            val = codeKey
-        }
-        let _xkey = xKey || 'X'
-        let _yKey = yKey || 'Y'
-        let _zKey = zKey || 'Z'
-        let _fKey = fKey || 'F'
-        if (checkVal(x)) {
-            val += ` ${_xkey}${x}`
-        }
-        if (checkVal(y)) {
-            val += ` ${_yKey}${y}`
-        }
-        if (checkVal(z)) {
-            val += ` ${_zKey}${z}`
-        }
-        if (checkVal(f)) {
-            val += ` ${_fKey}${f}`
-        }
-        return val
-    }
-    /** 直线 */
-    G1(params: CodeParams) {
-        const { x, y, z, f, xKey, yKey, zKey, fKey, codeKey } = params
-        let val: string = GCode.G1
-        if (typeof (codeKey) == 'string' && codeKey != '') {
-            val = codeKey
-        }
-        let _xkey = xKey || 'X'
-        let _yKey = yKey || 'Y'
-        let _zKey = zKey || 'Z'
-        let _fKey = fKey || 'F'
-
-
-        if (checkVal(x)) {
-            val += ` ${_xkey}${x}`
-        }
-        if (checkVal(y)) {
-            val += ` ${_yKey}${y}`
-        }
-        if (checkVal(z)) {
-            val += ` ${_zKey}${z}`
-        }
-        if (checkVal(f)) {
-            val += ` ${_fKey}${f}`
-        }
-
-
-
-        return val
-    }
-    /** 直线 */
-    G01(params: CodeParams) {
-        const { x, y, z, f, xKey, yKey, zKey, fKey, codeKey } = params
-        let val: string = GCode.G01
-        if (typeof (codeKey) == 'string' && codeKey != '') {
-            val = codeKey
-        }
-        let _xkey = xKey || 'X'
-        let _yKey = yKey || 'Y'
-        let _zKey = zKey || 'Z'
-        let _fKey = fKey || 'F'
-
-
-        if (checkVal(x)) {
-            val += ` ${_xkey}${x}`
-        }
-        if (checkVal(y)) {
-            val += ` ${_yKey}${y}`
-        }
-        if (checkVal(z)) {
-            val += ` ${_zKey}${z}`
-        }
-        if (checkVal(f)) {
-            val += ` ${_fKey}${f}`
-        }
-        return val
-    }
-    /** 顺时针 弧线 
-     * @param x  x坐标
-     * @param y  y坐标
-     * @param z  z坐标
-     * @param i  圆弧 对于起点的偏移量 x
-     * @param y  圆弧 对于起点的偏移量 Y
-     * @param z  圆弧 对于起点的偏移量 Y
-     * @param f  速度
-    */
-    G2(params: CodeParams) {
-        const { x, y, z, i, j, k, r, f, xKey, yKey, zKey, fKey, iKey, jKey, kKey, codeKey } = params
-        let val: string = GCode.G2
-        if (typeof (codeKey) == 'string' && codeKey != '') {
-            val = codeKey
-        }
-        let _xkey = xKey || 'X'
-        let _yKey = yKey || 'Y'
-        let _zKey = zKey || 'Z'
-        let _fKey = fKey || 'F'
-        let _iKey = iKey || 'I'
-        let _jKey = jKey || 'J'
-        let _kKey = kKey || 'K'
-
-        if (checkVal(x)) {
-            val += ` ${_xkey}${x}`
-        }
-        if (checkVal(y)) {
-            val += ` ${_yKey}${y}`
-        }
-        if (checkVal(z)) {
-            val += ` ${_zKey}${z}`
-        }
-        if (checkVal(r)) {
-            val += ` R${r}`
-        } else {
-            if (checkVal(i)) {
-                val += ` ${_iKey}${i}`
-            }
-            if (checkVal(j)) {
-                val += ` ${_jKey}${j}`
-            }
-            if (checkVal(k)) {
-                val += ` ${_kKey}${k}`
-            }
-        }
-        if (checkVal(f)) {
-            val += ` ${_fKey}${f}`
-        }
-        return val
-    }
-    /** 顺时针 弧线 
-     * @param x  x坐标
-     * @param y  y坐标
-     * @param z  z坐标
-     * @param i  圆弧 对于起点的偏移量 x
-     * @param y  圆弧 对于起点的偏移量 Y
-     * @param z  圆弧 对于起点的偏移量 Y
-     * @param f  速度
-    */
-    G02(params: CodeParams) {
-        const { x, y, z, i, j, k, r, f, xKey, yKey, zKey, fKey, iKey, jKey, kKey, codeKey } = params
-        let val: string = GCode.G02
-        if (typeof (codeKey) == 'string' && codeKey != '') {
-            val = codeKey
-        }
-        let _xkey = xKey || 'X'
-        let _yKey = yKey || 'Y'
-        let _zKey = zKey || 'Z'
-        let _fKey = fKey || 'F'
-        let _iKey = iKey || 'I'
-        let _jKey = jKey || 'J'
-        let _kKey = kKey || 'K'
-
-        if (checkVal(x)) {
-            val += ` ${_xkey}${x}`
-        }
-        if (checkVal(y)) {
-            val += ` ${_yKey}${y}`
-        }
-        if (checkVal(z)) {
-            val += ` ${_zKey}${z}`
-        }
-
-        if (checkVal(r)) {
-            val += ` R${r}`
-        } else {
-            if (checkVal(i)) {
-                val += ` ${_iKey}${i}`
-            }
-            if (checkVal(j)) {
-                val += ` ${_jKey}${j}`
-            }
-            if (checkVal(k)) {
-                val += ` ${_kKey}${k}`
-            }
-        }
-        if (checkVal(f)) {
-            val += ` ${_fKey}${f}`
-        }
-        return val
-    }
-    /** 逆时针 弧线 
-     * @param x  x坐标
-     * @param y  y坐标
-     * @param z  z坐标
-     * @param i  圆弧 对于起点的偏移量 x
-     * @param y  圆弧 对于起点的偏移量 Y
-     * @param z  圆弧 对于起点的偏移量 Y
-     * @param f  速度
-    */
-    G3(params: CodeParams) {
-        const { x, y, z, i, j, k, r, f, xKey, yKey, zKey, fKey, iKey, jKey, kKey, codeKey } = params
-        let val: string = GCode.G3
-        if (typeof (codeKey) == 'string' && codeKey != '') {
-            val = codeKey
-        }
-        let _xkey = xKey || 'X'
-        let _yKey = yKey || 'Y'
-        let _zKey = zKey || 'Z'
-        let _fKey = fKey || 'F'
-        let _iKey = iKey || 'I'
-        let _jKey = jKey || 'J'
-        let _kKey = kKey || 'K'
-
-        if (checkVal(x)) {
-            val += ` ${_xkey}${x}`
-        }
-        if (checkVal(y)) {
-            val += ` ${_yKey}${y}`
-        }
-        if (checkVal(z)) {
-            val += ` ${_zKey}${z}`
-        }
-
-        if (checkVal(r)) {
-            val += ` R${r}`
-        } else {
-            if (checkVal(i)) {
-                val += ` ${_iKey}${i}`
-            }
-            if (checkVal(j)) {
-                val += ` ${_jKey}${j}`
-            }
-            if (checkVal(k)) {
-                val += ` ${_kKey}${k}`
-            }
-        }
-        if (checkVal(f)) {
-            val += ` ${_fKey}${f}`
-        }
-        return val
-    }
-    /** 逆时针 弧线 
-     * @param x  x坐标
-     * @param y  y坐标
-     * @param z  z坐标
-     * @param i  圆弧 对于起点的偏移量 x
-     * @param y  圆弧 对于起点的偏移量 Y
-     * @param z  圆弧 对于起点的偏移量 Y
-     * @param f  速度
-    */
-    G03(params: CodeParams) {
-        const { x, y, z, i, j, k, r, f, xKey, yKey, zKey, fKey, iKey, jKey, kKey, codeKey } = params
-        let val: string = GCode.G03
-        if (typeof (codeKey) == 'string' && codeKey != '') {
-            val = codeKey
-        }
-        let _xkey = xKey || 'X'
-        let _yKey = yKey || 'Y'
-        let _zKey = zKey || 'Z'
-        let _fKey = fKey || 'F'
-        let _iKey = iKey || 'I'
-        let _jKey = jKey || 'J'
-        let _kKey = kKey || 'K'
-
-        if (checkVal(x)) {
-            val += ` ${_xkey}${x}`
-        }
-        if (checkVal(y)) {
-            val += ` ${_yKey}${y}`
-        }
-        if (checkVal(z)) {
-            val += ` ${_zKey}${z}`
-        }
-
-        if (checkVal(r)) {
-            val += ` R${r}`
-        } else {
-            if (checkVal(i)) {
-                val += ` ${_iKey}${i}`
-            }
-            if (checkVal(j)) {
-                val += ` ${_jKey}${j}`
-            }
-            if (checkVal(k)) {
-                val += ` ${_kKey}${k}`
-            }
-        }
-
-        if (checkVal(f)) {
-            val += ` ${_fKey}${f}`
-        }
-        return val
-    }
-    /** 主轴正转 
-     *  
-     * @param s 转速
-    */
-    M03(s: any) {
-        let val: string = GCode.M03
-        if (checkVal(s)) {
-            val += ` S${s}`
-        }
-        return val
-    }
-    /**主轴反向转 
-     * @param s 转速
-    */
-    M04(s: any) {
-        let val: string = GCode.M04
-        if (checkVal(s)) {
-            val += ` S${s}`
-        }
-        return val
-    }
-
-    /**主轴停止 */
-    M05() {
-        let val: string = GCode.M05
-
-        return val
-    }
-    /**换刀指令 */
-    M06(t: String) {
-        let val: string = GCode.M06
-        if (checkVal(t)) {
-            val += ` T${t}`
-        }
-        return val
-    }
-
-}

src/base.ts

@@ -1,15 +1,42 @@
-export class ConfigBase {
-    name: string = '';
-    version:string = '1.0.0';
-    enable:boolean = true;
-    [key: string]: any;
+import { ConfigBase } from "./models/config";
+
+
+/**
+ * 加工处理器上下文
+ */
+export interface ProcessorContext<TInput = any, TOutput = any, TConfig extends ConfigBase = ConfigBase> {
+    /**
+     * 输入数据
+     */
+    input?: TInput;
+    /**
+     * 合并配置文件与临时输入参
+     */
+    params?: TConfig;
+    /**
+     * 输出数据
+     */
+    output?: TOutput;
 }
 
-export interface FileOptions {
-    encode?: string;
-    addBOM?: boolean;
-}
-export interface FileInfo extends FileOptions {
-    name: string,
-    content: string | Blob | Uint8Array,
+/**
+ * 处理器基类
+ */
+export abstract class ProcessorBase<TInput, TOutput, TConfig extends ConfigBase> {
+    /**
+     * 处理器名，推荐使用 kebab-case 命名规则
+     * @example handle-ability
+     */
+    public abstract get name(): string;
+    /**
+     * 处理器版本，对处理器进行更新后记得修改版本号
+     * 格式使用 semver
+     * @default 1.0.0
+    */
+    public abstract get version(): string;
+    /**
+     * 处理器执行方法
+     * @param context 处理器上下文 
+     */
+    public abstract exec(context: ProcessorContext<TInput, TOutput, TConfig>): Promise<void> | void;
 }

src/index.ts

@@ -0,0 +1,12 @@
+export * from './base';
+export * from './parsers';
+export * from './models/config';
+export * from './models/knife';
+export * from './models/file';
+export * from './models/processors/rectLayout';
+export * from './models/processors/cutOrder';
+export * from './models/processItem';
+export * from './models/processors/modelProcessPoints';
+export * from './models/processors/cutPoint';
+export * from './models/processors/holeToModel';
+export * from './nc/ncWriter';

src/models/config.ts

@@ -0,0 +1,28 @@
+/**
+ * 配置基类,下划线开头的变量不会被序列化
+ */
+export class ConfigBase {
+    readonly name: string = '';
+    readonly version: string = '1.0.0';
+    [key: string]: any;
+
+    /**
+     * 加载反序列化数据
+     * @param data 
+     */
+    load(data: Record<string, unknown>) {
+        for (const key of Object.getOwnPropertyNames(this).filter(i => i[0] !== '_')) {
+            if (data[key] != undefined) {
+                this[key] = data[key];
+            }
+        }
+    }
+
+    /**
+     * 序列化json方法
+     * @returns 
+     */
+    toJson() {
+        return JSON.stringify(this, (k, v) => k[0] == '_' ? undefined : v);
+    }
+}

src/models/file.ts

@@ -0,0 +1,8 @@
+export interface FileOptions {
+    encode?: string;
+    addBOM?: boolean;
+}
+export interface FileInfo extends FileOptions {
+    name: string,
+    content: string | Blob | Uint8Array,
+}

src/models/knife.ts

@@ -0,0 +1,79 @@
+// 刀配置 移除 高级排钻，小刀辅助 ，可替代切割刀（AllowMilling替代）
+export enum KnifeType{
+    /**
+     * 开料
+     */
+    Cut = 1<<0,
+    /**
+     * 排钻
+     */
+    Hole = 1<<1,
+    /**
+     * 拉槽
+     */
+    Model = 1<<2,
+    /**
+     * 洗形
+     */
+    Milling = 1<<3,
+}
+/**
+ * 刀主轴
+ */
+export class KnifeSpindle{
+    id:number = 0;
+    /**启动代码*/
+    startCode = "";
+    /**停止代码 */
+    stopCode = '';
+    /**是否预启动 */
+    isPreStart = false;
+}
+export class Knife
+{
+    /**刀ID */
+    id = 0;
+    /**刀名称 */
+    name = '';
+    /**轴ID（旧名称axleID） */
+    spindleId = 0;
+    private _spindle?:KnifeSpindle
+    /**
+     * 刀主轴
+     */
+    get spindle(){
+        return this._spindle;
+    }
+    /**
+     * 设置刀主轴
+     */
+    set spindle(value){
+        this._spindle = value;
+    }
+    /**
+     * 刀类型,可复选
+     */
+    type:KnifeType = KnifeType.Cut;
+    /**刀直径mm */
+    diameter = 6;
+    /**最大深度 */
+    length = 40;
+    /**偏移X */
+    offsetX = 0;
+    /**偏移Y */
+    offsetY = 0;
+    /**偏移Z */
+    offsetZ = 0;
+    /**v型刀 角度 */
+    vKnifeAngle = 0;
+    /**刀运行速度 0为取系统默认 */
+    speed = 0;
+    /**下刀步进,0为不启用,例：加工深度12，步进5。实际加工为 5,5,2 */
+    depthStep :number = 0
+    /**刀启动代码*/
+    startCode = "";
+    /**刀停止代码 */
+    stopCode = '';
+    /**板外下刀 */
+    isOffBorderCut = false;
+}

src/models/processItem.ts

@@ -0,0 +1,27 @@
+
+export interface IPoint { x: number, y: number; }
+/**
+ * 加工数据
+ */
+export interface IProcessingItem {
+    /**
+     * 加工点数组
+     */
+    pts: IPoint[];
+    /**
+     * 凸度数组
+     */
+    buls: number[];
+    /**
+     * 加工深度
+     */
+    depth: number;
+    /**
+     * 半径
+     */
+    radius: number;
+    /**
+     * 刀ID
+     */
+    knifeId?: number;
+}

src/models/processors/cutOrder.ts

@@ -0,0 +1,57 @@
+/**
+ * 开料顺序（新）所使用的类型
+ * 
+ */
+
+import { ConfigBase } from "../config";
+
+/** 处理器入参 开料顺序(新)  
+ * @author lx
+ *
+ *  注：20250730 暂无配置 留个位置
+ */
+export class CutOrderConfig extends ConfigBase {
+    // [key:string] : any
+}
+
+/**
+ * 处理器输入数据源 开料顺序(新)  
+ */
+export type CutOrderInput = {
+    /**开料大板 宽 */
+    boardWidth: number,
+    /** 开料大板 长 */
+    boardLength: number,
+    /** 刀头大小（含修边）  */
+    gap: number,
+    /** 小板数据集合 */
+    blocks: CutOrderInputBlock[]
+}
+
+/**
+ * 处理器输出数据 开料顺序(新)  
+ */
+export type CutOrderOutput = {
+    blocks: CutOrderoutputBlock[]
+}
+/**
+ * 小板类型 输入
+ */
+export type CutOrderInputBlock = {
+    /** 小板唯一标识  */
+    id: string | number,
+    /** 排版长 */
+    length: number,
+    /** 排版宽 */
+    width: number,
+    /** 板件坐标X */
+    x: number,
+    /** 板件坐标y */
+    y: number,
+}
+/**
+ * 小板类型 输出
+ */
+export type CutOrderoutputBlock = CutOrderInputBlock & {
+    CutOrder: number
+}

src/models/processors/cutPoint.ts

@@ -0,0 +1,59 @@
+import { ConfigBase } from "../config"
+import { IProcessingItem } from "../processItem"
+
+/**
+ * 下刀点 入参
+ */
+export type CutPointInput = {
+
+    /** (余料板异形点) 开料大板的开料轮廓数据 若没有则需要传 开料大板宽、高*/
+    boardPointInfo?: IProcessingItem,
+    /** 开料大板宽 若有 boardPointInfo 则不需要传 */
+    boardWidth?: number,
+    /** 开料大板长 若有 boardPointInfo 则不需要传 */
+    boardLength?: number
+    /** 小板数据集 */
+    blocks?: CutPointInputBlock[]
+}
+/** 处理器输出---下刀点 */
+export type CutPointOutput = {
+    blocks: CutPointOutputBlock[]
+}
+
+/**
+ * 小板类型 输入
+ */
+export type CutPointInputBlock = {
+    /** 小板唯一标识  */
+    id: string | number;
+    /** 排版长 */
+    length: number;
+    /** 排版宽 */
+    width: number;
+    /** 板件坐标X */
+    x: number;
+    /** 板件坐标y */
+    y: number;
+    /** 开料顺序 */
+    cutOrder: number;
+    /** 
+     * 板件轮廓 
+     * 用以分析下刀点的板件轮廓 
+     * */
+    blockPoints: IProcessingItem
+    /** 是否异形  true 是异形  false 矩形 */
+    isUnRegular: boolean
+};
+
+/** 小板类型 输出 */
+export type CutPointOutputBlock = CutPointInputBlock & {
+    /** 下刀点  板件轮廓的下标 */
+    cutPointId?: number,
+}
+
+/** 下刀点配置 
+ * 
+ * 注：暂时没有配置项
+ */
+export declare class CutPointConfig extends ConfigBase {
+}

src/models/processors/holeToModel.ts

@@ -0,0 +1,39 @@
+import { ConfigBase } from "../config"
+import { IProcessingItem } from "../processItem"
+
+/** 处理器输入 -孔转造型*/
+export type HoleToModelInput = {
+    /** 孔信息 */
+    holeData: HoleToModelProcessingItem[],
+    /** 孔所在板件的优化后的坐标 X (可选)*/
+    placeX?: number,
+    /** 孔所在板件的优化后的坐标 Y (可选)*/
+    placeY?: number,
+    /** 孔所在板件的 厚度 */
+    thickness: number
+}
+/** 处理器输出-- 获取造型在大板的刀路 */
+export type HoleToModelOutput = {
+    /** 孔转造型 后的 造型数据 */
+    modelData: HoleToModelProcessingItem[],
+    /** 未处理的孔数据 以及信息 */
+    noHandleItem: NoHandleItemType[]
+}
+/** 孔转造型 未处理的数据 */
+export type NoHandleItemType = {
+    /** 未处理的孔信息 */
+    holeData: HoleToModelProcessingItem,
+    /** 未处理 说明 */
+    info: string
+}
+/** 处理器配置-- 获取造型在大板的刀路  */
+export declare class HoleToModelProcConfig extends ConfigBase {
+
+}
+
+ 
+/** 加工项的类型  */
+export type HoleToModelProcessingItem = IProcessingItem & {
+    /** 使用刀具的刀半径 */
+    knifeRadius: number
+}

src/models/processors/modelProcessPoints.ts

@@ -0,0 +1,113 @@
+import { ConfigBase } from "../config"
+import { IPoint } from "../processItem"
+
+/** 处理器输入-- 获取造型在大板的刀路 */
+export type ModelProcessPointsInput = {
+    /** 小板数据 */
+    block: ModelProcessPointsInputBlock,
+    /** 小板的最终的放置位置 */
+    targetPosition: PositionType
+}
+/** 处理器输入--小板 -- 获取造型在大板的刀路 */
+export type ModelProcessPointsInputBlock = {
+    /** 板件唯一标识 */
+    id: string | number,
+    /** 板件基于大板的 坐标X */
+    x: number,
+    /** 板件基于大板的 坐标y */
+    y: number,
+    /** 板件(小板)长 */
+    length: number,
+    /** 板件(小板)宽 */
+    width: number,
+    /** 造型数据 依据放置方式positionType 下的造型数据  默认为 依据放置方式positionType.FRONT 的造型数据 */
+    models: ModelProcessItem[],
+    /** 板件的原放置方式 默认为正面（0） 不传则为正面  原 placestyle*/
+    positionType?: PositionType,
+    /** 偏移值 */
+    offsetInfo: OffsetInfo
+
+}
+/** 板件 上下左右 偏移值信息 */
+export type OffsetInfo = {
+    top: number,
+    bottom: number,
+    left: number,
+    right: number,
+}
+/** 处理器输出--小板 -- 获取造型在大板的刀路 */
+export type ModelProcessPointsOutputBlock = {
+    /** 板件唯一标识 */
+    id: string | number
+    /** 放置方式 */
+    positionType: PositionType
+    /** 造型数据 */
+    models: ModelProcessItem[]
+    /** 板件(小板)长 */
+    length: number,
+    /** 板件(小板)宽 */
+    width: number,
+    /** 偏移值 */
+    offsetInfo: OffsetInfo
+}
+/** 处理器输出-- 获取造型在大板的刀路 */
+export type ModelProcessPointsOutput = {
+    block: ModelProcessPointsOutputBlock
+}
+
+/** 处理器配置-- 获取造型在大板的刀路  暂无 */
+export declare class ModelProcessPointsProcConfig extends ConfigBase {
+
+}
+
+
+/** 造型类 */
+export interface ModelProcessItem {
+    /** 加工项唯一标识 */
+    id?: string | number
+    /**
+    * 加工点数组
+    */
+    pts: IPoint[];
+    /**
+     * 凸度数组
+     */
+    buls: number[];
+    /** 加工面 */
+    face: FaceType
+
+}
+
+/** 加工面 */
+export enum FaceType {
+    /** 正面 */
+    FRONT = 0,
+    /** 反面 */
+    BACK = 1,
+}
+
+ 
+/** 小板的放置方式 */
+export enum PositionType {
+    /** 正面 */
+    FRONT = 0,
+    /** 正面右转 */
+    FRONT_TURN_RIGHT = 1,
+    /** 正面后转 */
+    FRONT_TURN_BACK = 2,
+    /** 正面左转 */
+    FRONT_TURN_LEFT = 3,
+    /** 反面 */
+    BACK = 4,
+    /** 反面右转 */
+    BACK_TURN_RIGHT = 5,
+    /** 反面后转 */
+    BACK_TURN_BACK = 6,
+    /** 反面左转 */
+    BACK_TURN_LEFT = 7,
+}
+
+
+/** 行为类型  */
+export type RotationAction = 'doNothing' | 'turnLeft' | 'turnRight' | 'turnAround'
+

src/models/processors/rectLayout.ts

@@ -0,0 +1,130 @@
+/**
+ * @file 矩形板件布局优化处理器使用的数据模型，包含优化输入、输出、大板、小板以及各类枚举
+ * @todo 目前仅适配了矩形优化，后续还需要对数据结构进行扩展
+ * @since 0.1.8
+ * @author CZY
+ */
+
+import { ConfigBase } from "../config";
+
+export interface RectLayoutProcInput {
+    /** 小板列表 */
+    blocks: RectLayoutBlock[];
+    /** 余料大板列表，可选，余料大板将会被优先优化，当余料大板被用尽时，则会使用配置中的大板尺寸进行优化 */
+    scrapBoards?: Array<{
+        /** 余料大板 */
+        board: RectLayoutBoard,
+        /** 大板张数 */
+        count: number;
+    }>;
+}
+
+export class RectLayoutProcConfig extends ConfigBase {
+    /** 大板高度 */
+    boardHeight: number = 1220;
+    /** 大板宽度 */
+    boardWidth: number = 2440;
+    /** 优化迭代次数 */
+    iterations: number = 50;
+    /** 双面加工优先排版 */
+    doubleSidedFirst: boolean = false;
+    /** 刀路间隙 */
+    gap: number = 0;
+    /** 运行标识 （其实改成方法更合适*/
+    _runFlag: 'running' | 'stopped' | 'terminated' = 'running';
+    /** 当出现优化结果时，进行回调 */
+    _onMessage?: (e: LayoutResult) => void;
+}
+
+
+export type RectLayoutProcOutput = never;
+
+/** 矩形优化小板输入 */
+export interface RectLayoutBlock {
+    /** 小板ID */
+    id: number;
+    /** 长 */
+    length: number;
+    /** 宽 */
+    width: number;
+    /** 纹路类型 */
+    waveType: WaveType;
+    /** 排版面类型 */
+    composingType: ComposingType;
+    /** 孔洞类型 */
+    holeType: HoleType;
+    /** 是否为矩形板 */
+    isRect?: boolean;
+    /** 是否需要双面加工 */
+    isdtwosided?: boolean;
+}
+
+/** 矩形优化大板输入 */
+export interface RectLayoutBoard {
+    length: number;
+    width: number;
+}
+
+/** 纹路类型 */
+export enum WaveType {
+    /** 正纹 */
+    Positive = 0,
+    /** 反纹 */
+    Reverse = 1,
+    /** 可翻转 */
+    CanReversal = 2,
+}
+
+/** 排版面 */
+export enum ComposingType {
+    /** 正面 */
+    Positive = 0,
+    Reverse = 1,   //反面
+    Arbitrary = 2  //任意
+}
+
+/** 孔类型 */
+export enum HoleType {
+    /** 没有孔 */
+    None = 0,
+    /** 正面 */
+    Positive = 1,
+    /** 反面 */
+    Reverse = 2,
+    /** 正反皆有 */
+    Two = 3
+}
+
+/** 布局大板 */
+export interface LayoutResultBoard {
+    id: string;
+    /** 大板高度 */
+    boardLength: number;
+    /** 大板宽度 */
+    boardWidth: number;
+}
+
+/** 布局小板 */
+export interface LayoutResultBlock {
+    id: string;
+    /** x坐标 */
+    x: number;
+    /** y坐标 */
+    y: number;
+    /** 高度 */
+    length: number;
+    /** 宽度 */
+    width: number;
+    /** 纹路类型 */
+    waveType: WaveType;
+}
+
+/** 优化布局结果 */
+export type LayoutResult = {
+    /** 大板列表 */
+    boards: LayoutResultBoard[],
+    /** 小板列表，其一维与boards长度对应，二维为小板列表 */
+    blocks: LayoutResultBlock[][],
+    /** 优化中被使用的余料大板，这个列表中的每一个元素代表使用了一片该规格的大板 */
+    usedScrapBoard: LayoutResultBoard[];
+};

src/nc/ncWriter.ts

@@ -0,0 +1,161 @@
+import { Knife } from "../models/knife";
+
+/**
+ * NC代码构建器接口，实现该接口来定义一个处理器用的NC代码构建器
+ * @author CZY
+ * @since 0.3.0
+ * @version 0.1.2
+ */
+export interface INcWriter {
+    get ncActions(): NcAction[];
+
+    /**
+     * 写入G代码或解析一条自定义代码
+     * @example
+     * gCode('G0', { x: 0, y: 0, z: 0, f: 25000 });
+     * gCode('CArc', { x: 0, y: 0, z: 0, b: 1, f: 25000 });
+     */
+    gCode<TCode extends (keyof typeof GCode | keyof typeof CCode)>(code: TCode, params: Partial<TCode extends keyof typeof GCode ? GCodeParams : CCodeParams>): void;
+
+    /** 基于刀具实体执行换刀操作 */
+    changeKnife(knife: Knife): void;
+
+    /** 添加一行注释 */
+    comment(content: string): void;
+
+    /**
+     * 记录一次NC加工操作
+     * 
+     * NC加工操作指的是一次完整的加工过程，例如一次排钻，一次造型切割，或是一次小板加工
+     * 
+     * 一次NC加工操作可能包含多行的GCode
+     * 
+     * 该方法旨在为NC文件提供记录加工步骤的能力
+     * 
+     * 返回本次NC操作的ID，此ID由内部生成
+     * @param type NC操作类型
+     * @returns 本次NC操作的ID
+     */
+    recordAction(type: NcActionType): string;
+
+    /** 直接在末尾追加任意字符串 */
+    append(str: string): void;
+
+    /** 直接在末尾追加一行任意字符串 */
+    appendLine(str: string): void;
+
+    /** 返回当前构建的NC代码 */
+    toString(): string;
+}
+
+/** 基础G代码 */
+export const GCode = {
+    /**
+     * 快速定位
+     * @param X X 坐标
+     * @param Y Y 坐标
+     * @param Z Z 坐标
+     * @param F 给进速度 mm/min
+     * @example G0 X0 Y0 F25000
+     */
+    G0: 'G0',
+
+    /**
+     * 直线插补
+     * @param X X 坐标
+     * @param Y Y 坐标
+     * @param Z Z 坐标
+     * @param F 给进速度 mm/min
+     * @example G1 X0 Y0 F25000
+     */
+    G1: 'G1',
+
+    /**
+     * 顺时针圆弧插补
+     * @param X X 坐标
+     * @param Y Y 坐标
+     * @param Z Z 坐标
+     * @param I （圆心坐标模式）从圆弧起点到圆心在X轴上的**增量距离**
+     * @param J （圆心坐标模式）从圆弧起点到圆心在Y轴上的**增量距离**
+     * @param K （圆心坐标模式）从圆弧起点到圆心在Z轴上的**增量距离**
+     * @param R （圆弧半径模式）指定圆弧的半径
+     * @example
+     * ; 假设当前刀具在 (X10, Y0)
+     * G2 X0 Y10 I-10 J0 F150 ; 顺时针圆弧到X0 Y10，圆心在(0,0) (10 + (-10) = 0, 0 + 0 = 0)
+     * G2 X0 Y10 R10 F150 ; 顺时针圆弧到X0 Y10，半径10 (小于等于180度)
+     */
+    G2: 'G2',
+
+    /**
+     * 逆时针圆弧插补
+     * @param X X 坐标
+     * @param Y Y 坐标
+     * @param Z Z 坐标
+     * @param I （圆心坐标模式）从圆弧起点到圆心在X轴上的**增量距离**
+     * @param J （圆心坐标模式）从圆弧起点到圆心在Y轴上的**增量距离**
+     * @param K （圆心坐标模式）从圆弧起点到圆心在Z轴上的**增量距离**
+     * @param R （圆弧半径模式）指定圆弧的半径
+     * @example
+     * ; 假设当前刀具在 (X10, Y0)
+     * G3 X0 Y-10 I-10 J0 F150 ; 逆时针圆弧到X0 Y-10，圆心在(0,0)
+     * G3 X0 Y-10 R-10 F150 ; 逆时针圆弧到X0 Y-10，半径10 (大于180度)
+     */
+    G3: 'G3',
+} as const;
+
+/** 自定义数控代码，由内部解析并实现，不直接输出给设备 */
+export const CCode = {
+    /**
+     * 自动圆弧插补
+     * @param X X 坐标
+     * @param Y Y 坐标
+     * @param Z Z 坐标
+     * @param B Bulge圆弧凸度，表示圆弧所包含角度的四分之一的正切值。当B=0时，圆弧为直线，当B>0时，圆弧为顺时针圆弧，当B<0时，圆弧为逆时针圆弧 (所谓“顺时针”和“逆时针”是指从起始点到结束点的绘制角度)
+     * @description 使用此命令时，X, Y, Z作为圆弧的结束点，当前刀具的位置作为起始点。
+     * @example
+     * FROM: CArc X0 Y10 Z0 B1
+     * TO: G2 X0 Y10 R5  
+     */
+    CArc: 'CArc',
+} as const;
+
+/** NC GCode 参数结构 */
+export class GCodeParams {
+    /** X坐标值 mm */
+    x: number = 0;
+    /** Y坐标值 mm */
+    y: number = 0;
+    /** Z坐标值 mm */
+    z: number = 0;
+    /** 使用圆弧指令(G2,G3)的圆弧半径模式(R)时，定义圆弧半径 */
+    r: number = 0;
+    /** 使用圆弧指令(G2,G3)的圆心坐标模式(I,J,K)时，定义圆心坐标在X轴上的增量距离 */
+    i: number = 0;
+    /** 使用圆弧指令(G2,G3)的圆心坐标模式(I,J,K)时，定义圆心坐标在Y轴上的增量距离 */
+    j: number = 0;
+    /** 给进速度(Feed Rate) mm/min */
+    f: number = 0;
+};
+
+/** 自定义数控代码参数结构 */
+export class CCodeParams {
+    /** X坐标值 mm */
+    x: number = 0;
+    /** Y坐标值 mm */
+    y: number = 0;
+    /** Z坐标值 mm */
+    z: number = 0;
+    /** 使用自动圆弧(CArc)命令时，定义圆弧凸度 */
+    b: number = 0;
+    /** 给进速度(Feed Rate) mm/min */
+    f: number = 0;
+}
+
+/** 单次NC加工行为 */
+export interface NcAction {
+    readonly id: string;
+    readonly type: NcActionType;
+    readonly lineIndex: number;
+}
+
+export type NcActionType = string;

src/processors.ts

@@ -1,7 +1,48 @@
-export abstract class ProcessorBase {
-    public readonly name: string = '';
-    public readonly version: string = '1.0.0';
-    public abstract exec(...args: any[]): any
+import { ProcessorBase } from "./base";
+import { ConfigBase } from "./models/config";
+import { FileInfo } from "./models/file";
+
+// todo: 类型参数待补完
+
+export class BlockInfo{
+
+}
+
+export class BlockProcessorConfig extends ConfigBase{
+
 }
 
 
+/**
+ * 用户板材数据过滤与转换
+ */
+export abstract class BlockProcessor extends ProcessorBase<BlockInfo[],BlockInfo[],BlockProcessorConfig>{
+
+}
+
+export class LayoutInput {
+
+}
+export class LayoutOutput{
+
+}
+
+export class LyaoutProcessorConfig extends ConfigBase{
+
+}
+
+export abstract class LayoutProcessor extends ProcessorBase<LayoutInput,LayoutOutput,LyaoutProcessorConfig>{
+    
+}
+
+export class ExporterInput{
+
+}
+
+export class ExporterProcessorConfig extends ConfigBase{
+
+}
+
+export abstract class ExporterProcessor extends ProcessorBase<ExporterInput,FileInfo,ExporterProcessorConfig>{
+    
+}

tests/paser.test.ts

@@ -1,5 +1,9 @@
 import { test } from '@jest/globals'
 import { DemoParser } from '../samples/demoParser';
+import { ProcessorModule, StepControllerProcessor } from '../src/device';
+import { ProcessorManager } from '../samples/demoDataHandleServer';
+import { demoHandleGroupCutting } from '../samples/demoDatahandle/demoDataHandle1';
+import testJson from "./test.json"
 test('demoParser', () => {
     const text = `FSTART
 TD 5
@@ -13,4 +17,23 @@ FEND
     const demoParser = new DemoParser();
     const result = demoParser.execTest(text);
     console.log(result);
+
+
+})
+
+test('data', async () => {
+    const json = testJson
+    // 创建处理器集合
+    const processorManager = new ProcessorManager<any, any>();
+    // 这里省略了 选择处理器的环节 --这里选了demo开料机
+    const cuttingHandle = new demoHandleGroupCutting()
+    // 注册处理器
+    processorManager.registerProcessor(cuttingHandle.processorName, cuttingHandle.processor)
+    // 使用XX处理器 会返回激活【正在使用】的 处理器
+    const processor = processorManager.useProcessor(cuttingHandle.processorName)
+ 
+    const res = await processor.process(json)
+    console.log('处理器所有流程都结束了', res);
+
+
 })

tsconfig.json

@@ -1,26 +1,29 @@
 {
-  "include": ["src"],
-  "exclude": ["samples","tests"],
+  "include": ["src/**/*"],
+  "exclude": ["node_modules","samples","tests"],
   "compilerOptions": {
     /* Visit https://aka.ms/tsconfig to read more about this file */
 
     /* Language and Environment */
-    "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-
+    // "target": "es2016",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "target": "ES6",  
     /* Modules */
     "module": "commonjs",                                /* Specify what module code is generated. */
     // "rootDir": "./",                                  /* Specify the root folder within your source files. */
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    "lib": ["DOM", "ES6", "ES2021"],
 
     /* Emit */
     "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
     "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+    "rootDir": "./src",
     "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
     // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
     "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
 
     /* Type Checking */
     "strict": true,                                      /* Enable all strict type-checking options. */
-    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+    "skipLibCheck": true,                              /* Skip type checking all .d.ts files. */
+    "sourceMap": true
   }
 }