chili3d 0.6.1

package/packages/chili-core/test/xyz.test.ts

@@ -0,0 +1,260 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { Precision, XY, XYZ } from "../src";
+
+describe("XYZ class tests", () => {
+    describe("Basic properties and constructor", () => {
+        test("should create XYZ instance with given values", () => {
+            const point = new XYZ(1, 2, 3);
+            expect(point.x).toBe(1);
+            expect(point.y).toBe(2);
+            expect(point.z).toBe(3);
+
+            expect(XYZ.fromArray(undefined as any)).toEqual(XYZ.zero);
+            expect(XYZ.fromArray([1, 2, 3])).toEqual(point);
+            expect(XYZ.fromArray([1, 2])).toEqual(new XYZ(1, 2, 0));
+            expect(XYZ.fromArray([1, 2, 3, 4])).toEqual(new XYZ(1, 2, 3));
+        });
+
+        test("should have correct static properties", () => {
+            expect(XYZ.zero).toEqual(new XYZ(0, 0, 0));
+            expect(XYZ.unitX).toEqual(new XYZ(1, 0, 0));
+            expect(XYZ.unitY).toEqual(new XYZ(0, 1, 0));
+            expect(XYZ.unitZ).toEqual(new XYZ(0, 0, 1));
+            expect(XYZ.unitNX).toEqual(new XYZ(-1, 0, 0));
+            expect(XYZ.unitNY).toEqual(new XYZ(0, -1, 0));
+            expect(XYZ.unitNZ).toEqual(new XYZ(0, 0, -1));
+            expect(XYZ.one).toEqual(new XYZ(1, 1, 1));
+        });
+
+        test("should convert to string and array correctly", () => {
+            const point = new XYZ(1, 2, 3);
+            expect(point.toString()).toBe("1, 2, 3");
+            expect(point.toArray()).toEqual([1, 2, 3]);
+        });
+    });
+
+    describe("Arithmetic operations", () => {
+        test("should add vectors correctly", () => {
+            const a = new XYZ(1, 2, 3);
+            const b = new XYZ(4, 5, 6);
+            const result = a.add(b);
+            expect(result).toEqual(new XYZ(5, 7, 9));
+        });
+
+        test("should subtract vectors correctly", () => {
+            const a = new XYZ(5, 7, 9);
+            const b = new XYZ(1, 2, 3);
+            const result = a.sub(b);
+            expect(result).toEqual(new XYZ(4, 5, 6));
+        });
+
+        test("should multiply by scalar correctly", () => {
+            const point = new XYZ(1, 2, 3);
+            const result = point.multiply(3);
+            expect(result).toEqual(new XYZ(3, 6, 9));
+        });
+
+        test("should divide by scalar correctly", () => {
+            const point = new XYZ(10, 20, 30);
+            const result = point.divided(2);
+            expect(result).toEqual(new XYZ(5, 10, 15));
+        });
+
+        test("should return undefined when dividing by zero", () => {
+            const point = new XYZ(10, 20, 30);
+            const result = point.divided(0);
+            expect(result).toBeUndefined();
+
+            const result2 = point.divided(Precision.Float / 2); // very small number
+            expect(result2).toBeUndefined();
+        });
+
+        test("should reverse the vector correctly", () => {
+            const point = new XYZ(1, 2, 3);
+            const reversed = point.reverse();
+            expect(reversed).toEqual(new XYZ(-1, -2, -3));
+
+            const zero = XYZ.zero.reverse();
+            expect(zero).toEqual(new XYZ(0, 0, 0));
+        });
+    });
+
+    describe("Mathematical operations", () => {
+        test("should calculate cross product correctly", () => {
+            const a = new XYZ(1, 0, 0);
+            const b = new XYZ(0, 1, 0);
+            const result = a.cross(b);
+            expect(result).toEqual(new XYZ(0, 0, 1));
+
+            const c = new XYZ(2, 3, 4);
+            const d = new XYZ(5, 6, 7);
+            const result2 = c.cross(d);
+            expect(result2).toEqual(new XYZ(-3, 6, -3)); // (3*7-4*6, 4*5-2*7, 2*6-3*5)
+        });
+
+        test("should calculate dot product correctly", () => {
+            const a = new XYZ(1, 2, 3);
+            const b = new XYZ(4, 5, 6);
+            expect(a.dot(b)).toBe(32); // 1*4 + 2*5 + 3*6 = 4 + 10 + 18 = 32
+        });
+
+        test("should calculate length and length squared correctly", () => {
+            const point = new XYZ(3, 4, 5);
+            expect(point.lengthSq()).toBe(50); // 9 + 16 + 25
+            expect(point.length()).toBe(Math.sqrt(50));
+        });
+
+        test("should normalize vector correctly", () => {
+            const point = new XYZ(3, 0, 0);
+            const normalized = point.normalize();
+            expect(normalized).toEqual(new XYZ(1, 0, 0));
+
+            const unit = new XYZ(1, 1, 1);
+            const normalized2 = unit.normalize();
+            const length = Math.sqrt(3);
+            expect(normalized2).toEqual(new XYZ(1 / length, 1 / length, 1 / length));
+        });
+
+        test("should return undefined for zero vector normalization", () => {
+            const normalized = XYZ.zero.normalize();
+            expect(normalized).toBeUndefined();
+        });
+    });
+
+    describe("Distance and geometric operations", () => {
+        test("should calculate distance correctly", () => {
+            const a = new XYZ(0, 0, 0);
+            const b = new XYZ(3, 4, 0);
+            expect(a.distanceTo(b)).toBe(5); // 3-4-5 triangle
+
+            const c = new XYZ(1, 1, 1);
+            const d = new XYZ(4, 5, 1);
+            expect(c.distanceTo(d)).toBe(5); // 3-4-5 triangle in xy plane
+        });
+
+        test("should calculate center correctly", () => {
+            const p1 = new XYZ(0, 0, 0);
+            const p2 = new XYZ(4, 6, 8);
+            const center = XYZ.center(p1, p2);
+            expect(center).toEqual(new XYZ(2, 3, 4));
+        });
+    });
+
+    describe("Angle operations", () => {
+        test("should calculate angle correctly", () => {
+            const a = new XYZ(10, 0, 0);
+            const b = new XYZ(0, 10, 0);
+            expect(a.angleTo(b)).toBe(Math.PI / 2);
+            expect(a.angleTo(new XYZ(10, 0, 0))).toBe(0);
+            expect(a.angleTo(new XYZ(10, 10, 0))).toBe(Math.PI / 4);
+            expect(a.angleTo(new XYZ(0, 10, 0))).toBe(Math.PI / 2);
+            expect(a.angleTo(new XYZ(-10, 10, 0))).toBe((Math.PI * 3) / 4);
+            expect(a.angleTo(new XYZ(-10, 0, 0))).toBe(Math.PI);
+            expect(a.angleTo(new XYZ(-10, -10, 0))).toBe((Math.PI * 3) / 4);
+            expect(a.angleTo(new XYZ(10, -10, 0))).toBe(Math.PI / 4);
+        });
+
+        test("should return undefined for zero vector angle", () => {
+            expect(XYZ.zero.angleTo(new XYZ(0, 0, 0))).toBe(undefined);
+            expect(XYZ.zero.angleTo(new XYZ(1, 0, 0))).toBeUndefined();
+            expect(new XYZ(1, 0, 0).angleTo(XYZ.zero)).toBeUndefined();
+        });
+
+        test("should calculate angle on plane correctly", () => {
+            const a = new XYZ(10, 0, 0);
+            const b = new XYZ(0, 10, 0);
+            expect(a.angleOnPlaneTo(b, XYZ.unitZ)).toBe(Math.PI / 2);
+            expect(a.angleOnPlaneTo(new XYZ(10, 0, 0), XYZ.unitZ)).toBe(0);
+            expect(a.angleOnPlaneTo(new XYZ(10, 10, 0), XYZ.unitZ)).toBe(Math.PI / 4);
+            expect(a.angleOnPlaneTo(new XYZ(0, 10, 0), XYZ.unitZ)).toBe(Math.PI / 2);
+            expect(a.angleOnPlaneTo(new XYZ(-10, 10, 0), XYZ.unitZ)).toBe((Math.PI * 3) / 4);
+            expect(a.angleOnPlaneTo(new XYZ(-10, 0, 0), XYZ.unitZ)).toBe(Math.PI);
+            expect(a.angleOnPlaneTo(new XYZ(-10, -10, 0), XYZ.unitZ)).toBe((Math.PI * 5) / 4);
+            expect(a.angleOnPlaneTo(new XYZ(10, -10, 0), XYZ.unitZ)).toBe((Math.PI * 7) / 4);
+
+            expect(new XYZ(10, 10, 0).angleOnPlaneTo(a, XYZ.unitZ)).toBe((Math.PI * 7) / 4);
+            expect(a.angleOnPlaneTo(new XYZ(10, 10, 0), new XYZ(0, 0, -1))).toBe((Math.PI * 7) / 4);
+        });
+
+        test("should return undefined for zero normal in angleOnPlaneTo", () => {
+            const a = new XYZ(1, 0, 0);
+            const b = new XYZ(0, 1, 0);
+            expect(a.angleOnPlaneTo(b, XYZ.zero)).toBeUndefined();
+            expect(XYZ.zero.angleOnPlaneTo(XYZ.zero, XYZ.unitZ)).toBe(undefined);
+        });
+    });
+
+    describe("Rotation operations", () => {
+        test("should rotate vector correctly", () => {
+            const v = XYZ.unitX.add(XYZ.unitZ);
+            expect(v.rotate(v, 90)?.isEqualTo(v)).toBeTruthy();
+            expect(
+                XYZ.unitX.rotate(XYZ.unitZ, Math.PI / 4)?.isEqualTo(new XYZ(1, 1, 0).normalize()!),
+            ).toBeTruthy();
+            expect(XYZ.unitX.rotate(XYZ.unitZ, Math.PI / 2)?.isEqualTo(new XYZ(0, 1, 0))).toBeTruthy();
+            expect(XYZ.unitX.rotate(XYZ.unitZ, Math.PI / 1)?.isEqualTo(new XYZ(-1, 0, 0))).toBeTruthy();
+            expect(XYZ.unitX.rotate(XYZ.unitZ, Math.PI * 1.5)?.isEqualTo(new XYZ(0, -1, 0))).toBeTruthy();
+
+            const result = XYZ.unitX.rotate(XYZ.unitZ, Math.PI / 2);
+            expect(result?.isEqualTo(XYZ.unitY, 1e-10)).toBeTruthy();
+
+            const result2 = XYZ.unitY.rotate(XYZ.unitZ, Math.PI / 2);
+            expect(result2?.isEqualTo(XYZ.unitX.reverse(), 1e-10)).toBeTruthy();
+        });
+
+        test("should handle edge cases for rotation", () => {
+            const result = XYZ.unitX.rotate(XYZ.zero, Math.PI / 2);
+            expect(result).toBeUndefined();
+        });
+    });
+
+    describe("Comparison methods", () => {
+        test("isEqualTo should work correctly", () => {
+            const a = new XYZ(1, 2, 3);
+            const b = new XYZ(1, 2, 3);
+            expect(a.isEqualTo(b)).toBeTruthy();
+
+            const c = new XYZ(1.1, 2, 3);
+            expect(a.isEqualTo(c, 0.2)).toBeTruthy(); // within tolerance
+            expect(a.isEqualTo(c, 0.05)).toBeFalsy(); // outside tolerance
+        });
+
+        test("isPerpendicularTo should work correctly", () => {
+            const a = new XYZ(1, 0, 0);
+            const b = new XYZ(0, 1, 0);
+            expect(a.isPerpendicularTo(b)).toBeTruthy();
+            expect(a.isPerpendicularTo(b.reverse())).toBeTruthy();
+
+            const c = new XYZ(1, 1, 0);
+            expect(a.isPerpendicularTo(c, 0.1)).toBeFalsy();
+        });
+
+        test("isParallelTo should work correctly", () => {
+            const a = new XYZ(1, 0, 0);
+            const b = new XYZ(2, 0, 0);
+            expect(a.isParallelTo(b)).toBeTruthy();
+
+            const c = new XYZ(-1, 0, 0);
+            expect(a.isParallelTo(c)).toBeTruthy(); // opposite direction is still parallel
+        });
+
+        test("isOppositeTo should work correctly", () => {
+            const a = new XYZ(1, 0, 0);
+            const b = new XYZ(-1, 0, 0);
+            expect(a.isOppositeTo(b)).toBeTruthy();
+
+            const c = new XYZ(0, 1, 0);
+            expect(a.isOppositeTo(c)).toBeFalsy();
+        });
+    });
+
+    describe("XY class tests", () => {
+        test("should calculate angle for XY vectors", () => {
+            const v1 = XY.unitX;
+            const v2 = XY.unitY;
+            expect(v1.angleTo(v2)).toBe(Math.PI / 2);
+        });
+    });
+});

package/packages/chili-geo/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "chili-geo",
+  "version": "0.6.1",
+  "description": "",
+  "main": "src/index.ts",
+  "devDependencies": {
+    "chili-core": "*"
+  }
+}

package/packages/chili-geo/src/index.ts

@@ -0,0 +1,4 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export * from "./utils";

package/packages/chili-geo/src/utils.ts

@@ -0,0 +1,113 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    ICurve,
+    type IEdge,
+    type IFace,
+    type IWire,
+    Orientation,
+    Precision,
+    Result,
+    ShapeType,
+    XYZ,
+} from "chili-core";
+
+export class GeoUtils {
+    static nearestPoint(wire: IWire, point: XYZ): { edge: IEdge; point: XYZ } {
+        let minDistance = Number.MAX_VALUE;
+        let nearest: { edge: IEdge; point: XYZ } | undefined;
+
+        for (const edge of wire.findSubShapes(ShapeType.Edge) as IEdge[]) {
+            const tempPoint = edge.curve.nearestFromPoint(point);
+            if (tempPoint.distance < minDistance) {
+                nearest = { edge, point: tempPoint.point };
+                minDistance = tempPoint.distance;
+            }
+        }
+        return nearest!;
+    }
+
+    static curveNormal(curve: ICurve) {
+        if (ICurve.isTrimmed(curve)) {
+            curve = curve.basisCurve;
+        }
+
+        if (ICurve.isConic(curve)) {
+            return curve.axis;
+        }
+        const vec = curve.dn(0, 1);
+        if (vec.isParallelTo(XYZ.unitX)) return XYZ.unitZ;
+        return vec.cross(XYZ.unitX).normalize()!;
+    }
+
+    private static wireNormal(wire: IWire): XYZ {
+        const edges = wire.findSubShapes(ShapeType.Edge) as IEdge[];
+        if (edges.length === 0) {
+            console.warn("Empty wire");
+            return XYZ.unitZ;
+        } else if (edges.length === 1) {
+            return GeoUtils.curveNormal(edges[0].curve);
+        } else {
+            const curve1 = edges[0].curve;
+            const curve2 = edges[1].curve;
+            const p1 = curve1.value(curve1.firstParameter());
+            const p2 = curve1.value(curve1.lastParameter());
+            const p3 = curve2.value(curve2.firstParameter());
+            const p4 = curve2.value(curve2.lastParameter());
+            const v1 = p2.sub(p1);
+            const v2 = p4.sub(p3);
+            const normal = v1.cross(v2).normalize()!;
+            if (wire.orientation() === Orientation.REVERSED) {
+                return normal.reverse();
+            }
+            return normal;
+        }
+    }
+
+    static isCCW(normal: XYZ, wire: IWire): boolean {
+        const testNormal = GeoUtils.wireNormal(wire);
+        return testNormal.dot(normal) > 0.001;
+    }
+
+    static findNextEdge(wire: IWire, edge: IEdge): Result<IEdge> {
+        const curve = edge.curve;
+        const point = curve.value(curve.lastParameter());
+
+        for (const e of wire.findSubShapes(ShapeType.Edge)) {
+            if (e.isEqual(edge)) continue;
+            const testCurve = (e as IEdge).curve;
+            if (
+                point.distanceTo(testCurve.value(testCurve.firstParameter())) < Precision.Distance ||
+                point.distanceTo(testCurve.value(testCurve.lastParameter())) < Precision.Distance
+            ) {
+                return Result.ok(e as IEdge);
+            }
+        }
+        return Result.err("Cannot find next edge");
+    }
+
+    static normal(shape: IFace | IWire | IEdge): XYZ {
+        if (shape.shapeType === ShapeType.Face) {
+            return (shape as IFace).normal(0, 0)[1];
+        }
+
+        if (shape.shapeType === ShapeType.Edge) {
+            const curve = (shape as IEdge).curve;
+            return GeoUtils.curveNormal(curve);
+        }
+
+        return GeoUtils.wireNormal(shape as IWire);
+    }
+
+    static intersects(edge: IEdge, otherEdges: IEdge[]): { point: XYZ; parameter: number }[] {
+        const result: { point: XYZ; parameter: number }[] = [];
+        otherEdges.forEach((e) => {
+            const intersect = edge.intersect(e);
+            if (intersect.length > 0) {
+                result.push(...intersect);
+            }
+        });
+        return result;
+    }
+}

package/packages/chili-i18n/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "chili-i18n",
+  "version": "0.6.1",
+  "description": "",
+  "main": "src/index.ts",
+  "devDependencies": {
+    "chili-core": "*"
+  }
+}

package/packages/chili-i18n/src/en.ts

@@ -0,0 +1,270 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import type { Locale } from "chili-core";
+
+export default {
+    display: "English",
+    language: "en",
+    translation: {
+        "arc.angle": "Angle",
+        "arc.start": "Start",
+        "axis.x": "X Axis",
+        "axis.y": "Y Axis",
+        "axis.z": "Z Axis",
+        "body.arc": "Arc",
+        "body.bolean": "Boolean",
+        "body.box": "Box",
+        "body.pyramid": "Pyramid",
+        "body.cylinder": "Cylinder",
+        "body.cone": "Cone",
+        "body.group": "Group",
+        "body.sphere": "Sphere",
+        "body.ellipse": "Ellipse",
+        "body.circle": "Circle",
+        "body.face": "Face",
+        "body.fuse": "Fuse",
+        "body.imported": "Imported",
+        "body.line": "Line",
+        "body.polygon": "Pline",
+        "body.prism": "Prism",
+        "body.rect": "Rectangle",
+        "body.revol": "Revolve",
+        "body.sweep": "Sweep",
+        "body.wire": "Wire",
+        "box.dx": "Length",
+        "box.dy": "Width",
+        "box.dz": "Height",
+        "body.editableShape": "Editable Shape",
+        "body.meshNode": "Mesh Node",
+        "body.multiShape": "Multi Shape",
+        "circle.center": "Center",
+        "circle.radius": "Radius",
+        "ellipsoid.radiusX": "RadiusX",
+        "ellipsoid.radiusY": "RadiusY",
+        "ellipsoid.radiusZ": "RadiusZ",
+        "ellipse.majorRadius": "major Radius",
+        "ellipse.minorRadius": "minor Radius",
+        "command.act.alignCamera": "Align Camera",
+        "command.boolean.common": "Intersect",
+        "command.boolean.cut": "Cut",
+        "command.boolean.join": "Join",
+        "command.convert.fuse": "Fuse",
+        "command.create.revol": "Revolve",
+        "command.create.sweep": "Sweep",
+        "command.convert.toFace": "To Face",
+        "command.convert.toShell": "To Shell",
+        "command.convert.toSolid": "To Solid",
+        "command.convert.toWire": "To Wire",
+        "command.convert.curveProjection": "Projection",
+        "command.create.arc": "Arc",
+        "command.create.bezier": "Bezier",
+        "command.create.box": "Box",
+        "command.create.circle": "Circle",
+        "command.create.cone": "Cone",
+        "command.create.copyShape": "Copy Shape",
+        "command.create.cylinder": "Cylinder",
+        "command.create.ellipse": "Ellipse",
+        "command.create.ellipsoid": "Ellipsoid",
+        "command.create.extrude": "Extrude",
+        "command.create.folder": "Folder",
+        "command.create.group": "Group",
+        "command.create.line": "Line",
+        "command.create.loft": "Loft",
+        "command.create.offset": "Offset",
+        "command.create.polygon": "Pline",
+        "command.create.pyramid": "Pyramid",
+        "command.create.rect": "Rectangle",
+        "command.create.section": "Section",
+        "command.create.sphere": "Sphere",
+        "command.create.thickSolid": "Thick Solid",
+        "command.doc.new": "New Document",
+        "command.doc.open": "Open Document",
+        "command.doc.save": "Save Document",
+        "command.doc.saveToFile": "Save To File",
+        "command.edit.redo": "Redo",
+        "command.edit.undo": "Undo",
+        "command.file.export": "Export",
+        "command.file.import": "Import",
+        "command.measure.angle": "Angle",
+        "command.measure.length": "Length",
+        "command.measure.select": "Select",
+        "command.modify.array": "Array",
+        "command.modify.break": "Break",
+        "command.modify.brushAdd": "Brush Add",
+        "command.modify.brushRemove": "Brush Remove",
+        "command.modify.brushClear": "Brush Clear",
+        "command.modify.chamfer": "Chamfer",
+        "command.modify.deleteNode": "Delete Node",
+        "command.modify.explode": "Explode",
+        "command.modify.fillet": "Fillet",
+        "command.modify.mirror": "Mirror",
+        "command.modify.move": "Move",
+        "command.modify.removeFeature": "Remove Feature",
+        "command.modify.removeShapes": "Remove Shapes",
+        "command.modify.rotate": "Rotate",
+        "command.modify.split": "Split",
+        "command.modify.trim": "Trim",
+        "command.special.last": "__Last_COMMAND__",
+        "command.test.performance": "Performance Test",
+        "command.wechat.group": "Wechat",
+        "command.workingPlane.alignToPlane": "Align",
+        "command.workingPlane.fromSection": "Section",
+        "command.workingPlane.set": "Set",
+        "command.workingPlane.toggleDynamic": "Toggle",
+        "common.angle": "Angle",
+        "common.area": "Area",
+        "common.back": "Back",
+        "common.isGroup": "Group",
+        "common.language": "Language",
+        "common.location": "Location",
+        "common.3DNavigation": "3D Navigation",
+        "common.theme": "Theme",
+        "common.theme.light": "Light",
+        "common.theme.dark": "Dark",
+        "common.theme.system": "System",
+        "common.cancel": "Cancel",
+        "common.clone": "Clone",
+        "common.color": "Color",
+        "common.count": "Count",
+        "common.confirm": "Confirm",
+        "common.general": "General",
+        "common.length": "Length",
+        "common.dir": "Direction",
+        "common.material": "Material",
+        "common.matrix": "Matrix",
+        "common.name": "Name",
+        "common.normal": "Normal",
+        "common.numberX": "Number X",
+        "common.numberY": "Number Y",
+        "common.numberZ": "Number Z",
+        "common.opacity": "Opacity",
+        "common.thickness": "Thickness",
+        "common.type": "Type",
+        "common.volume": "Volume",
+        "dialog.title.selectWorkingPlane": "Select Working Plane",
+        "entity.editable": "Editable Entity",
+        "entity.parameter": "Parameter Entity",
+        "error.default:{0}": "error: {0}",
+        "error.input.cannotInputANumber": "Overlap with reference point, 1 number cannot be entered",
+        "error.input.invalidNumber": "Please enter a valid number, separated by ,",
+        "error.input.threeNumberCanBeInput": "Reference point is empty, only 3 numbers can be entered",
+        "error.input.unsupportedInputs": "Exceeds the maximum number of inputs",
+        "error.import.unsupportedFileType:{0}": "Unsupported file type: {0}",
+        "error.export.noNodeCanBeExported": "No node can be exported",
+        "file.format": "Format",
+        "home.recent": "Recent",
+        "home.welcome": "Welcome to chili3d",
+        "items.header": "Items",
+        "items.tool.delete": "Delete",
+        "items.tool.expandAll": "Expand All",
+        "items.tool.newFolder": "New Folder",
+        "items.tool.unexpandAll": "Unexpand all",
+        "line.end": "End",
+        "line.start": "Start",
+        "line.type.line": "Line",
+        "line.type.xline": "XLine",
+        "material.texture.image": "Image",
+        "material.texture.rotation": "Rotation",
+        "material.texture.wrapS": "Wrap S",
+        "material.texture.wrapT": "Wrap T",
+        "material.texture.repeat": "Repeat",
+        "material.texture.offset": "Offset",
+        "material.map": "Map",
+        "material.specular": "Specular",
+        "material.shininess": "Shininess",
+        "material.emissive": "Emissive",
+        "material.specularMap": "Specular Map",
+        "material.normalMap": "Normal Map",
+        "material.bumpMap": "BumpMap",
+        "material.roughnessMap": "Roughness Map",
+        "material.emissiveMap": "Emissive Map",
+        "material.metalness": "Metalness",
+        "material.metalnessMap": "Metalness Map",
+        "material.roughness": "Roughness",
+        "model.visible": "Visible",
+        "option.command.continuity": "Continuity",
+        "option.command.circularPattern": "Circular Pattern",
+        "option.command.repeat": "Repeat",
+        "option.command.isFace": "Face",
+        "option.command.isSolid": "Solid",
+        "option.command.isRuled": "Ruled",
+        "option.command.isRoundCorner": "Round Corner",
+        "option.command.thickness": "Thickness",
+        "option.command.isConnected": "Connected",
+        "option.command.isConvertInstance": "Convert Instance",
+        "option.command.insertPoint": "Insert Point",
+        "polygon.points": "Points",
+        "prompt.default{0}{1}":
+            "{0} to pan the view, {1} to rotate the view, Mouse wheel to scroll the zoom view",
+        "prompt.deleteDocument{0}": "Do you want to delete {0}?",
+        "prompt.pickCircleCenter": "pick center, ESC key to cancel",
+        "prompt.pickFistPoint": "Pick first point, ESC key to cancel",
+        "prompt.pickNextPoint": "pick next point, ESC key to cancel",
+        "prompt.pickRadius": "input radius, ESC key to cancel",
+        "prompt.polygon.close": "Close",
+        "prompt.saveDocument{0}": "Do you want to save the changes to {0}?",
+        "prompt.select.edges": "Please select edges",
+        "prompt.select.faces": "Please select faces",
+        "prompt.select.models": "Please select models",
+        "prompt.select.noModelSelected": "No model selected",
+        "prompt.select.section": "Please select section",
+        "prompt.select.shape": "Please select shape",
+        "prompt.select.solids": "Please select solids",
+        "prompt.select.path": "Please select path",
+        "prompt.select.vertexes": "Please select vertexes",
+        "prompt.select.wires": "Please select wires",
+        "toast.snap.notFoundValidPoint": "No valid point",
+        "properties.group.transform": "Transform",
+        "properties.header": "Properties",
+        "properties.multivalue": "Multi Value",
+        "rect.dx": "Length",
+        "rect.dy": "Width",
+        "ribbon.group.2d": "2D",
+        "ribbon.group.3d": "3D",
+        "ribbon.group.act": "Act",
+        "ribbon.group.boolean": "Boolean",
+        "ribbon.group.converter": "Converter",
+        "ribbon.group.draw": "Sketch",
+        "ribbon.group.importExport": "Import/Export",
+        "ribbon.group.measure": "Measure",
+        "ribbon.group.modify": "Modify",
+        "ribbon.group.other": "Other",
+        "ribbon.group.selection": "Selection",
+        "ribbon.group.tools": "Tools",
+        "ribbon.group.workingPlane": "Working Plane",
+        "ribbon.tab.draw": "Sketch",
+        "ribbon.tab.file": "File",
+        "ribbon.tab.tools": "Tools",
+        "ribbon.tab.startup": "Startup",
+        "snap.center": "Center",
+        "snap.end": "End",
+        "snap.intersection": "Intersection",
+        "snap.mid": "Middle",
+        "snap.perpendicular": "Perpendicular",
+        "snap.nearest": "Nearest",
+        "statusBar.snap": "Snap",
+        "statusBar.tracking": "Tracking",
+        "toast.command.{0}excuting": "Command {0} is runing",
+        "toast.converter.error": "Converter error",
+        "toast.converter.invalidColor": "The color is invalid",
+        "toast.delete{0}Objects": "Deleted {0} objects",
+        "toast.document.noActivated": "No document activated",
+        "toast.document.saved": "Document saved",
+        "toast.downloading": "Downloading",
+        "toast.excuting{0}": "Excuting {0}",
+        "toast.fail": "Fail",
+        "toast.read.error": "Read error",
+        "toast.select.noSelected": "No selected",
+        "toast.success": "Success",
+        "transform.rotation": "Rotation",
+        "transform.scale": "Scale",
+        "transform.translation": "Translation",
+        "vertex.point": "Point",
+        "viewport.orthographic": "Orthographic",
+        "viewport.perspective": "Perspective",
+        "viewport.fitContent": "Fit Content",
+        "viewport.zoomIn": "Zoom In",
+        "viewport.zoomOut": "Zoom Out",
+    },
+} satisfies Locale;

package/packages/chili-i18n/src/index.ts

@@ -0,0 +1,8 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import en from "./en";
+import ptBr from "./pt-br";
+import zhCn from "./zh-cn";
+
+export { en, ptBr, zhCn };