คุณลักษณะและฟังก์ชันการทำงาน

Aspose.3D FOSS for TypeScript คือไลบรารี Node.js ที่ใช้ใบอนุญาต MIT สำหรับการโหลด, สร้าง, และส่งออกฉาก 3D มาพร้อมกับการกำหนดประเภท TypeScript ที่สมบูรณ์, ขึ้นอยู่กับ runtime เพียงตัวเดียว (xmldom), และรองรับไฟล์ฟอร์แมต 3D หลักจำนวนหกรูปแบบ หน้านี้เป็นเอกสารอ้างอิงหลักสำหรับทุกส่วนของฟีเจอร์และรวมตัวอย่างโค้ด TypeScript ที่สามารถรันได้สำหรับแต่ละส่วน.

การติดตั้งและตั้งค่า

ติดตั้งแพคเกจจาก npm ด้วยคำสั่งเดียว:

npm install @aspose/3d

แพ็กเกจนี้มุ่งเป้าไปที่ CommonJS และต้องการ Node.js เวอร์ชัน 18 หรือใหม่กว่า หลังการติดตั้ง ให้ตรวจสอบว่า tsconfig.json รวมตัวเลือกคอมไพเลอร์ต่อไปนี้เพื่อความเข้ากันได้เต็มรูปแบบ:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "moduleResolution": "node",
    "esModuleInterop": true,
    "strict": true
  }
}

นำเข้า main Scene คลาสจากรูทของแพ็กเกจ ตัวเลือกคลาสที่เฉพาะเจาะจงตามฟอร์แมตจะถูกนำเข้าจากเส้นทางย่อยที่สอดคล้องกัน:

import { Scene } from '@aspose/3d';
import { ObjLoadOptions } from '@aspose/3d/formats/obj';
import { GltfSaveOptions, GltfFormat } from '@aspose/3d/formats/gltf';

คุณลักษณะและฟังก์ชันการทำงาน

การสนับสนุนรูปแบบ

Aspose.3D FOSS for TypeScript อ่านและเขียนรูปแบบไฟล์ 3D หลัก 6 รูปแบบ การตรวจจับรูปแบบทำโดยอัตโนมัติจากเลขมาจิก (magic numbers) ของไบนารีเมื่อโหลด ดังนั้นคุณไม่จำเป็นต้องระบุรูปแบบแหล่งที่มาชัดเจน.

การโหลด OBJ พร้อมวัสดุ:

import { Scene } from '@aspose/3d';
import { ObjLoadOptions } from '@aspose/3d/formats/obj';

const scene = new Scene();
const options = new ObjLoadOptions();
options.enableMaterials = true;
options.flipCoordinateSystem = false;
options.scale = 1.0;
options.normalizeNormal = true;
scene.open('model.obj', options);

การบันทึกเป็น GLB (binary glTF):

import { Scene } from '@aspose/3d';
import { GltfSaveOptions, GltfFormat } from '@aspose/3d/formats/gltf';

const scene = new Scene();
// ... build or load scene content

const opts = new GltfSaveOptions();
opts.binaryMode = true;
scene.save('output.glb', GltfFormat.getInstance(), opts);

กราฟฉาก

เนื้อหา 3D ทั้งหมดถูกจัดระเบียบเป็นต้นไม้ของ Node วัตถุที่มีรากที่ scene.rootNode. แต่ละโหนดสามารถบรรจุ Entity (a Mesh, Camera, Light, หรืออื่น SceneObject) Transform ที่กำหนดตำแหน่งของมันสัมพันธ์กับพาเรนท์ของมัน.

คลาสสำคัญของกราฟฉาก:

• Scene: ตัวคอนเทนเนอร์ระดับบนสุด; เก็บ rootNode และ animationClips
• Node: โหนดต้นไม้ที่มีชื่อ childNodes, entity, transform, และ materials
• Entity: คลาสฐานสำหรับอ็อบเจ็กต์ที่สามารถแนบได้ (Mesh, Camera, Light)
• SceneObject: คลาสฐานที่ใช้ร่วมกันโดย Node และ Entity
• A3DObject: คลาสฐานรากที่มี name และ property bag
• Transform: การแปลตำแหน่ง, การหมุน (Euler และ Quaternion), และสเกล

การเดินทางผ่านกราฟฉาก:

import { Scene, Node, Mesh } from '@aspose/3d';

const scene = new Scene();
scene.open('model.obj');

function visit(node: Node, depth: number = 0): void {
  const indent = '  '.repeat(depth);
  console.log(`${indent}Node: ${node.name}`);
  if (node.entity) {
    console.log(`${indent}  Entity: ${node.entity.constructor.name}`);
  }
  for (const child of node.childNodes) {
    visit(child, depth + 1);
  }
}

visit(scene.rootNode);

สร้างลำดับชั้นของซีนโดยโปรแกรมมิ่ง:

import { Scene, Node } from '@aspose/3d';

const scene = new Scene();
const parent = scene.rootNode.createChildNode('chassis');
const wheel = parent.createChildNode('wheel_fl');
wheel.transform.translation.set(0.9, -0.3, 1.4);

เรขาคณิตและ Mesh

Mesh เป็นประเภทเรขาคณิตหลัก มันขยาย Geometry และเปิดเผยจุดควบคุม (vertices), ดัชนีโพลิกอน, และองค์ประกอบเวอร์เท็กซ์สำหรับ normals, UVs, และ vertex colors.

คลาสเรขาคณิตสำคัญ:

• Mesh: โพลิกอนเมชที่มี controlPoints และ polygonCount
• Geometry: คลาสฐานที่มีการจัดการองค์ประกอบเวอร์เท็กซ์
• VertexElementNormal: เวกเตอร์ปกติต่อเวอร์เท็กซ์หรือต่อเวอร์เท็กซ์ของโพลิกอน
• VertexElementUV: พิกัดเทกเจอร์ (หนึ่งหรือหลายช่อง UV)
• VertexElementVertexColor: ข้อมูลสีต่อเวอร์เท็กซ์
• MappingMode: ควบคุมวิธีที่ข้อมูลองค์ประกอบแมปไปยังโพลิกอน (CONTROL_POINT, POLYGON_VERTEX, POLYGON, EDGE, ALL_SAME)
• ReferenceMode: ควบคุมกลยุทธ์การทำดัชนี (DIRECT, INDEX, INDEX_TO_DIRECT)
• VertexElementType: ระบุความหมายขององค์ประกอบเวอร์เท็กซ์
• TextureMapping: การระบุลำดับช่องเทกเจอร์

การอ่านข้อมูลเมชจากซีนที่โหลดแล้ว:

import { Scene, Mesh, VertexElementType } from '@aspose/3d';

const scene = new Scene();
scene.open('model.stl');

for (const node of scene.rootNode.childNodes) {
  if (node.entity instanceof Mesh) {
    const mesh = node.entity as Mesh;
    console.log(`Mesh "${node.name}": ${mesh.controlPoints.length} vertices, ${mesh.polygonCount} polygons`);

    const normals = mesh.getElement(VertexElementType.NORMAL);
    if (normals) {
      console.log(`  Normal mapping: ${normals.mappingMode}`);
    }
  }
}

ระบบวัสดุ

Aspose.3D FOSS for TypeScript รองรับสามประเภทวัสดุที่ครอบคลุมช่วงเต็มตั้งแต่การเชดดิ้ง Phong แบบเก่าไปจนถึงการเรนเดอร์แบบฟิสิกส์พื้นฐาน:

• LambertMaterial: สีกระจายและสีแวดล้อม; แปลงเป็นวัสดุ OBJ/DAE แบบง่าย
• PhongMaterial: เพิ่มสีสเปคูลาร์, ความเงา, และการเรืองแสง; เป็นประเภทวัสดุ OBJ เริ่มต้น
• PbrMaterial: โมเดลความหยาบ/โลหะตามฟิสิกส์; ใช้สำหรับการนำเข้าและส่งออก glTF 2.0

การอ่านวัสดุจากฉาก OBJ ที่โหลดแล้ว:

import { Scene, PhongMaterial, LambertMaterial } from '@aspose/3d';
import { ObjLoadOptions } from '@aspose/3d/formats/obj';

const scene = new Scene();
const options = new ObjLoadOptions();
options.enableMaterials = true;
scene.open('model.obj', options);

for (const node of scene.rootNode.childNodes) {
  for (const mat of node.materials) {
    if (mat instanceof PhongMaterial) {
      const phong = mat as PhongMaterial;
      console.log(`  Phong: diffuse=${JSON.stringify(phong.diffuseColor)}, shininess=${phong.shininess}`);
    } else if (mat instanceof LambertMaterial) {
      console.log(`  Lambert: diffuse=${JSON.stringify((mat as LambertMaterial).diffuseColor)}`);
    }
  }
}

การใช้วัสดุ PBR เมื่อสร้างฉาก glTF:

import { Scene, Node, PbrMaterial } from '@aspose/3d';
import { Vector3 } from '@aspose/3d';
import { GltfSaveOptions, GltfFormat } from '@aspose/3d/formats/gltf';

const scene = new Scene();
const node = scene.rootNode.createChildNode('sphere');
const mat = new PbrMaterial();
mat.albedo = new Vector3(0.8, 0.2, 0.2);   // red-tinted albedo; albedo starts null, must assign
mat.metallicFactor = 0.0;
mat.roughnessFactor = 0.5;
node.material = mat;

const opts = new GltfSaveOptions();
opts.binaryMode = false;
scene.save('output.gltf', GltfFormat.getInstance(), opts);

ยูทิลิตี้คณิตศาสตร์

ไลบรารีมาพร้อมกับชุดประเภทคณิตศาสตร์ 3 มิติที่ครบถ้วน, ทั้งหมดมีการกำหนดประเภทอย่างเต็มที่:

• Vector3: เวกเตอร์ 3 ส่วนประกอบ; รองรับ minus(), times(), dot(), cross(), normalize(), length, angleBetween()
• Vector4: เวกเตอร์ 4 ส่วนประกอบสำหรับพิกัดเชิงเนื้อเดียว
• Matrix4: เมทริกซ์การแปลง 4×4 พร้อมกับ concatenate(), transpose, decompose, setTRS
• Quaternion: ควอเทอร์เนียนการหมุนพร้อมกับ fromEulerAngle() (คงที่, เอกพจน์), eulerAngles() (เมธอดของอินสแตนซ์), slerp(), normalize()
• BoundingBox: กล่องขอบเขตที่จัดแนวตามแกนกับ minimum, maximum, center, size, merge
• FVector3: เวอร์ชัน single-precision ของ Vector3 ใช้ใน vertex element data

การคำนวณกล่องขอบเขตจากเวอร์เท็กซ์เมช:

import { Scene, Mesh, Vector3, BoundingBox } from '@aspose/3d';

const scene = new Scene();
scene.open('model.obj');

let box = new BoundingBox();
for (const node of scene.rootNode.childNodes) {
  if (node.entity instanceof Mesh) {
    for (const pt of (node.entity as Mesh).controlPoints) {
      box.merge(new Vector3(pt.x, pt.y, pt.z));
    }
  }
}
console.log('Center:', box.center);
console.log('Extents:', box.size);

การสร้างการแปลงจากมุมออยเลอร์:

import { Quaternion, Vector3, Matrix4 } from '@aspose/3d';

const rot = Quaternion.fromEulerAngle(0, Math.PI / 4, 0); // 45° around Y
const mat = new Matrix4();
mat.setTRS(new Vector3(0, 0, 0), rot, new Vector3(1, 1, 1));

ระบบแอนิเมชัน

API แอนิเมชันจำลองคลิป, โหนด, ช่องสัญญาณ, และลำดับคีย์เฟรม:

• AnimationClip: คอลเลกชันที่ตั้งชื่อของโหนดแอนิเมชัน; เข้าถึงผ่าน scene.animationClips; เปิดเผย animations: AnimationNode[]
• AnimationNode: กลุ่มที่ตั้งชื่อของ BindPoints; สร้างผ่าน clip.createAnimationNode(name), เข้าถึงผ่าน clip.animations
• BindPoint: ผูกกับ AnimationNode กับคุณสมบัติเฉพาะบนวัตถุฉาก; เปิดเผย property และ channelsCount
• AnimationChannel: ขยาย KeyframeSequence; เก็บแยก keyframeSequence; เข้าถึงผ่าน bindPoint.getChannel(name)
• KeyFrame: คู่เวลา/ค่าเดียว; มีต่อคีย์เฟรม interpolation: Interpolation
• KeyframeSequence: รายการที่เรียงลำดับของ KeyFrame วัตถุผ่าน keyFrames; มี preBehavior และ postBehavior (Extrapolation)
• Interpolation: enum: LINEAR, CONSTANT, BEZIER, B_SPLINE, CARDINAL_SPLINE, TCB_SPLINE
• Extrapolation: คลาสที่มี type: ExtrapolationType และ repeatCount: number
• ExtrapolationType: enum: CONSTANT, GRADIENT, CYCLE, CYCLE_RELATIVE, OSCILLATE

การอ่านข้อมูลแอนิเมชันจากฉากที่โหลดแล้ว:

import { Scene, AnimationNode, BindPoint } from '@aspose/3d';

const scene = new Scene();
scene.open('animated.dae');   // COLLADA animation import is supported

for (const clip of scene.animationClips) {
  console.log(`Clip: "${clip.name}"`);
  for (const animNode of clip.animations) {          // clip.animations, not clip.nodes
    console.log(`  AnimationNode: ${animNode.name}`);
    for (const bp of animNode.bindPoints) {           // animNode.bindPoints, not animNode.channels
      console.log(`  BindPoint: property="${bp.property.name}", channels=${bp.channelsCount}`);
    }
  }
}

การสนับสนุน Stream และ Buffer

ใช้ scene.openFromBuffer() เพื่อโหลดฉาก 3D โดยตรงจากหน่วยความจำใน Buffer. นี่คือรูปแบบที่แนะนำสำหรับฟังก์ชันแบบไม่มีเซิร์ฟเวอร์, พายป์ไลน์สตรีมมิ่ง, และการประมวลผลแอสเซทที่ดึงมาผ่าน HTTP โดยไม่ต้องเขียนลงดิสก์.

import { Scene } from '@aspose/3d';
import { ObjLoadOptions } from '@aspose/3d/formats/obj';
import * as fs from 'fs';

// Load file into memory, then parse from buffer
const buffer: Buffer = fs.readFileSync('model.obj');
const scene = new Scene();
const options = new ObjLoadOptions();
options.enableMaterials = true;
scene.openFromBuffer(buffer, options);

for (const node of scene.rootNode.childNodes) {
  if (node.entity) {
    console.log(node.name, node.entity.constructor.name);
  }
}

การตรวจจับรูปแบบอัตโนมัติจาก magic number ของไบนารีทำงานเมื่อโหลดจาก buffer, ดังนั้นไฟล์ GLB, STL binary, และ 3MF จะถูกระบุโดยอัตโนมัติโดยไม่ต้องระบุพารามิเตอร์รูปแบบ.

ตัวอย่างการใช้งาน

ตัวอย่างที่ 1: โหลด OBJ และส่งออกเป็น GLB

ตัวอย่างนี้โหลดไฟล์ Wavefront OBJ พร้อมวัสดุ, จากนั้นส่งออกฉากใหม่เป็นไฟล์ binary glTF (GLB) ที่เหมาะสำหรับการใช้งานบนเว็บและเอนจินเกม.

import { Scene } from '@aspose/3d';
import { ObjLoadOptions } from '@aspose/3d/formats/obj';
import { GltfSaveOptions, GltfFormat } from '@aspose/3d/formats/gltf';

function convertObjToGlb(inputPath: string, outputPath: string): void {
  const scene = new Scene();

  const loadOpts = new ObjLoadOptions();
  loadOpts.enableMaterials = true;
  loadOpts.flipCoordinateSystem = false;
  loadOpts.normalizeNormal = true;
  scene.open(inputPath, loadOpts);

  // Report what was loaded
  for (const node of scene.rootNode.childNodes) {
    if (node.entity) {
      console.log(`Loaded: ${node.name} (${node.entity.constructor.name})`);
    }
  }

  const saveOpts = new GltfSaveOptions();
  saveOpts.binaryMode = true; // write .glb instead of .gltf + .bin
  scene.save(outputPath, GltfFormat.getInstance(), saveOpts);

  console.log(`Exported GLB to: ${outputPath}`);
}

convertObjToGlb('input.obj', 'output.glb');

ตัวอย่างที่ 2: การทำ Round-Trip STL พร้อมการตรวจสอบ Normal

ตัวอย่างนี้โหลดไฟล์ STL ไบนารี, พิมพ์ข้อมูล normal ของแต่ละเวอร์เท็กซ์, จากนั้นส่งออกฉากใหม่เป็น ASCII STL และตรวจสอบความถูกต้องของการทำ roundtrip.

import { Scene, Mesh, VertexElementNormal, VertexElementType } from '@aspose/3d';
import { StlLoadOptions, StlSaveOptions } from '@aspose/3d/formats/stl';

const scene = new Scene();
const loadOpts = new StlLoadOptions();
scene.open('model.stl', loadOpts);

let totalPolygons = 0;
for (const node of scene.rootNode.childNodes) {
  if (node.entity instanceof Mesh) {
    const mesh = node.entity as Mesh;
    totalPolygons += mesh.polygonCount;

    const normElem = mesh.getElement(VertexElementType.NORMAL) as VertexElementNormal | null;
    if (normElem) {
      console.log(`  Normals: ${normElem.data.length} entries, mapping=${normElem.mappingMode}`);
    }
  }
}
console.log(`Total polygons: ${totalPolygons}`);

// Re-export as ASCII STL
const saveOpts = new StlSaveOptions();
saveOpts.binaryMode = false; // ASCII output
scene.save('output_ascii.stl', saveOpts);

ตัวอย่าง 3: สร้างฉากโดยโปรแกรมและบันทึกเป็น glTF

ตัวอย่างนี้สร้างฉากพร้อมวัสดุ PBR ตั้งแต่ต้นและบันทึกเป็นไฟล์ JSON glTF.

import { Scene, Mesh, PbrMaterial, Vector4, Vector3 } from '@aspose/3d';
import { GltfSaveOptions, GltfFormat } from '@aspose/3d/formats/gltf';

const scene = new Scene();
const node = scene.rootNode.createChildNode('floor');

// Build a simple quad mesh (two triangles)
// controlPoints are Vector4 (x, y, z, w) where w=1 for positions
const mesh = new Mesh();
mesh.controlPoints.push(
  new Vector4(-1, 0, -1, 1),
  new Vector4( 1, 0, -1, 1),
  new Vector4( 1, 0,  1, 1),
  new Vector4(-1, 0,  1, 1),
);
mesh.createPolygon([0, 1, 2]);
mesh.createPolygon([0, 2, 3]);
node.entity = mesh;

// Apply a PBR material
const mat = new PbrMaterial();
mat.albedo = new Vector3(0.6, 0.6, 0.6);   // albedo starts null, must assign
mat.metallicFactor = 0.0;
mat.roughnessFactor = 0.8;
node.material = mat;

// Save as JSON glTF
const opts = new GltfSaveOptions();
opts.binaryMode = false;
scene.save('floor.gltf', GltfFormat.getInstance(), opts);
console.log('Scene written to floor.gltf');

เคล็ดลับและแนวปฏิบัติที่ดีที่สุด

• ใช้ ObjLoadOptions.enableMaterials = true เมื่อใดก็ตามที่คุณต้องการข้อมูลวัสดุจากไฟล์ .mtl หากไม่มีมัน รายการวัสดุในแต่ละโหนดจะว่างเปล่า.
• แนะนำให้ใช้ binaryMode = true สำหรับ GLB เมื่อสร้างสินทรัพย์สำหรับเว็บหรือเอนจินเกม ไฟล์ GLB แบบไบนารีเป็นไฟล์เดียวที่รวมทุกอย่างไว้และโหลดได้เร็วกว่าในเบราว์เซอร์และเอนจินเมื่อเทียบกับการแยก JSON + .bin.
• ใช้ openFromBuffer() ในสภาพแวดล้อมแบบไม่มีเซิร์ฟเวอร์ เพื่อหลีกเลี่ยงการอ่าน/เขียนไฟล์ชั่วคราว ดึงสินทรัพย์ ส่งต่อ Buffer โดยตรง และเขียนผลลัพธ์ไปยังสตรีมหรือบัฟเฟอร์อื่น.
• ตรวจสอบ node.entity ก่อนทำการแคสท์: ไม่ใช่ทุกโหนดที่มีเอนทิตี้ ควรป้องกันเสมอด้วย instanceof การตรวจสอบก่อนเข้าถึง Mesh-specific properties เช่น controlPoints.
• ตั้งค่า normalizeNormal = true ใน ObjLoadOptions เมื่อไฟล์ OBJ ต้นทางของคุณมาจากแหล่งที่ไม่เชื่อถือได้ สิ่งนี้จะป้องกันไม่ให้นอร์มอลที่ผิดรูปแพร่กระจายไปยังขั้นตอนการเรนเดอร์หรือการตรวจสอบต่อไป.
• เก็บ strict: true ใน tsconfig.json: ไลบรารีนี้เขียนด้วย noImplicitAny และ strictNullChecks. การปิดใช้งาน strict ทำให้ข้อผิดพลาดประเภทจริงถูกซ่อนและทำลายคุณค่าของ API ที่มีการกำหนดประเภท.
• เดินทางผ่าน childNodes, ไม่ใช่ลูปดัชนี: the childNodes คุณสมบัติจะคืนค่าเป็น iterable; หลีกเลี่ยงการพึ่งพาการเข้าถึงด้วยดัชนีตัวเลขเพื่อความเข้ากันได้ในอนาคต.

ปัญหาทั่วไป

คำถามที่พบบ่อย

ไลบรารีต้องการส่วนเสริมเนทีฟหรือแพ็กเกจระบบใดหรือไม่? ไม่มี. Aspose.3D FOSS สำหรับ TypeScript มีการพึ่งพา runtime เพียงหนึ่งรายการ: xmldom, ซึ่งเป็น JavaScript แท้และติดตั้งโดยอัตโนมัติผ่าน npm. ไม่มี .node ส่วนเสริมแบบ native และไม่ต้องติดตั้งแพ็กเกจระบบใดๆ.

เวอร์ชันของ Node.js ที่รองรับคืออะไร? Node.js 18, 20, และ 22 LTS. ไลบรารีนี้มุ่งเป้าไปที่เอาต์พุต CommonJS และใช้คุณลักษณะภาษา ES2020 ภายใน.

ฉันสามารถใช้ไลบรารีนี้ในบันเดิลของเบราว์เซอร์ (webpack/esbuild) ได้หรือไม่? ไลบรารีนี้มุ่งเป้าไปที่ Node.js และใช้ Node.js fs และ Buffer API. การบันเดิลสำหรับเบราว์เซอร์ไม่ได้รับการสนับสนุนอย่างเป็นทางการ สำหรับการใช้ในเบราว์เซอร์ ให้โหลดซีนบนเซิร์ฟเวอร์แล้วส่งผลลัพธ์ (เช่นเป็น GLB) ไปยังไคลเอนต์.

ความแตกต่างระหว่างคืออะไร GltfSaveOptions.binaryMode = true และ false? binaryMode = false ให้ผลลัพธ์เป็น .gltf ไฟล์ JSON พร้อมไฟล์แยก .bin บัฟเฟอร์ไบนารี sidecar. binaryMode = true สร้างไฟล์เดียวที่เป็นอิสระ .glb ไฟล์ ใช้ true สำหรับการส่งมอบสินทรัพย์ในขั้นตอนการผลิต.

ฉันสามารถโหลดไฟล์จากการตอบสนอง HTTP ได้โดยไม่ต้องบันทึกลงดิสก์หรือไม่? ใช่. ดึงการตอบสนองเป็น Buffer (เช่น ใช้ node-fetch หรือในตัว fetch ใน Node 18+), จากนั้นเรียก scene.openFromBuffer(buffer, options).

การสนับสนุน FBX ครบถ้วนหรือไม่? ไม่. มีคลาสผู้นำเข้าและส่งออก FBX อยู่ในไลบรารี, แต่ FBX ยังไม่ได้เชื่อมต่อกับ Scene.open() หรือ Scene.save() การตรวจจับอัตโนมัติ. การเรียก scene.open('file.fbx') จะไม่เรียกใช้ผู้นำเข้า FBX; ไฟล์จะถูกจัดการโดยเส้นทางสำรอง STL. ใช้คลาสผู้นำเข้า/ส่งออกเฉพาะ FBX โดยตรงหากคุณต้องการ I/O ของ FBX. ดูตารางการสนับสนุนรูปแบบด้านบนที่ระบุว่า FBX เป็น No*.

ไลบรารีนี้รองรับ TypeScript 4.x หรือไม่? แนะนำให้ใช้ TypeScript 5.0 ขึ้นไป. TypeScript 4.7 ขึ้นไปควรทำงานได้ในทางปฏิบัติ, แต่ไลบรารีได้รับการทดสอบและพัฒนาต่อจาก 5.0 ขึ้นไป.

สรุปอ้างอิง API