@domgell/gltf-parser 1.0.0 → 1.0.1

package/package.json

@@ -1,18 +1,15 @@
 {
   "name": "@domgell/gltf-parser",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "main": "src/index.ts",
   "exports": "./src/index.ts",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": ["gltf", "glb", "mesh", "parser"],
   "author": "domgell",
   "license": "ISC",
   "description": "Parse .GLTF/.GLF files into JS objects",
+  "keywords": ["gltf", "glb", "mesh", "parser"],
   "dependencies": {
-    "gltf-types": "file:../gltf-types",
+    "@domgell/gltf-types": "*",
+    "@domgell/ts-util": "*",
     "dom-game-math": "*"
-  },
-  "devDependencies": {}
+  }
 }

package/src/Parser.ts

@@ -1,15 +1,14 @@
 import {
     AccessorArrayType,
     AccessorConstructorType,
-    assert,
     chunk,
-    fail,
     getTransform,
 } from "./util.ts";
 import * as Parsed from "./types.ts";
-import * as GLTF from "gltf-types";
+import * as GLTF from "@domgell/gltf-types";
 import {mat4, TransformOrder} from "dom-game-math";
 import {Matrix4x4, TextureFilterMap, TextureWrapModeMap} from "./types.ts";
+import {assert, fail} from "@domgell/ts-util";
 
 export type ParserOptions = {
     transformOrder: TransformOrder,
@@ -30,7 +29,6 @@ export class Parser {
 
         const data = await r.arrayBuffer();
         const dataView = new DataView(data);
-
         let offset = 12;
 
         // Get JSON Header
@@ -39,12 +37,12 @@ export class Parser {
         const textDecoder = new TextDecoder("utf-8");
         const json = textDecoder.decode(jsonChunkData);
         const header = JSON.parse(json);
-
         offset += 8 + jsonChunkLength;
 
         // Get binary data
         const binaryChunkLength = dataView.getUint32(offset, true);
         const binary = new ArrayBuffer(binaryChunkLength);
+
         const binaryChunkView = new Uint8Array(binary);
         binaryChunkView.set(new Uint8Array(data, offset + 8, binaryChunkLength));
 
@@ -63,7 +61,6 @@ export class Parser {
             ?? fail(`Accessor at index ${index} not found`);
 
         assert(accessor.bufferView !== undefined, "Accessor bufferView is undefined");
-
         const bufferView = this.header.bufferViews[accessor.bufferView];
         const byteOffset = (bufferView.byteOffset ?? 0) + (accessor.byteOffset ?? 0);
 
@@ -79,6 +76,7 @@ export class Parser {
             5125: Uint32Array,
             5126: Float32Array,
         }[accessor.componentType];
+
         assert(assertType.name === type.name, `Mismatched types: requested '${type.name}' but got '${assertType.name}'`);
 
         const byteLength = numComponents * accessor.count * type.BYTES_PER_ELEMENT;
@@ -89,6 +87,7 @@ export class Parser {
 
     async mesh(gltfMesh: GLTF.Mesh) {
         const primitives = new Array<Parsed.MeshPrimitive>(gltfMesh.primitives.length);
+
         for (let i = 0; i < primitives.length; i++) {
             primitives[i] = await this.primitive(gltfMesh.primitives[i]);
         }
@@ -152,11 +151,8 @@ export class Parser {
 
             const children = gltfJoint.children?.map(i => this.header.nodes![i].name!) ?? [];
 
-            //const inverseBindTransform = inverseBindMatrices[jointIndex];
             const inverseBindTransform = inverseBindMatrices[i];
-
             joints[gltfJoint.name] = {name: gltfJoint.name, transform, children, inverseBindTransform};
-
             i++;
         }
 
@@ -166,6 +162,7 @@ export class Parser {
         // Set parents
         for (let name in joints) {
             const joint = joints[name];
+
             for (let childName of joint.children) {
                 joints[childName].parent = name;
             }
@@ -183,6 +180,7 @@ export class Parser {
 
         // TEMP: Calculate global inverse transform
         const skinParentNode = this.header.nodes.find(n => n.children?.includes(gltfSkin.joints[0]));
+
         const globalInverseTransform = skinParentNode
             ? getTransform(skinParentNode, this.options.transformOrder)
             : Array.from(mat4.idt) as Matrix4x4;
@@ -192,6 +190,7 @@ export class Parser {
 
     animation(gltfAnimation: GLTF.Animation): Parsed.Animation {
         assert(this.header.nodes !== undefined, "`Nodes` is undefined");
+
         const channels: Record<string, Parsed.AnimationChannel> = {};
         let duration = 0;
 
@@ -201,18 +200,15 @@ export class Parser {
 
             // Init channel if not already present
             channels[gltfTargetNode.name] ??= {translation: [], rotation: [], scale: []};
-
             const sampler = gltfAnimation.samplers[gltfChannel.sampler];
             const times = this.accessor(sampler.input, Float32Array);
             const values = this.accessor(sampler.output, Float32Array);
-
             const numComponents = values.length / times.length;
             assert(numComponents === 3 || numComponents === 4, `Invalid number of components: '${numComponents}'`);
 
             // Set keyframes array of current 'path', e.g. 'translation'
             const keyframes = chunk(values, numComponents).map((value, i) => ({time: times[i], value}));
             channels[gltfTargetNode.name][gltfChannel.target.path] = keyframes as any;
-
             duration = Math.max(duration, ...keyframes.map(k => k.time));
         }
 
@@ -247,8 +243,11 @@ export class Parser {
         }
 
         const alpha: Parsed.MaterialAlphaInfo = {
+
             mode: gltfMaterial.alphaMode ?? "OPAQUE",
+
             cutoff: gltfMaterial.alphaCutoff ?? 0.5,
+
         };
 
         const doubleSided = gltfMaterial.doubleSided ?? false;
@@ -271,6 +270,7 @@ export class Parser {
 
         // Parse sampler
         const sampler: Parsed.Sampler = {wrap: {s: "repeat", t: "repeat"}, filter: {min: "linear", mag: "linear"}};
+
         if (this.header.samplers !== undefined && gltfTexture.sampler !== undefined) {
             const gltfSampler = this.header.samplers[gltfTexture.sampler];
 
@@ -290,12 +290,14 @@ export class Parser {
             const response = await fetch(this.path + gltfImage.uri);
             assert(response.ok, `Failed to fetch image at URI: '${gltfImage.uri}'`);
             const blob = await response.blob();
+
             return await createImageBitmap(blob);
         }
         // Image from buffer
         else {
             assert(this.header.bufferViews !== undefined, "Header `BufferViews` property is undefined");
             assert(this.header.buffers !== undefined, "Header `Buffers` property is undefined");
+
             const bufferView = this.header.bufferViews[gltfImage.bufferView];
             const buffer = this.header.buffers[bufferView.buffer];
 
@@ -306,6 +308,7 @@ export class Parser {
             // TODO: buffer length + bufferView offset (?)
             const data = this.binary.slice(bufferView.byteOffset ?? 0, (bufferView.byteOffset ?? 0) + bufferView.byteLength);
             const blob = new Blob([new Uint8Array(data)]);
+
             return await createImageBitmap(blob);
         }
     }

package/src/index.ts

@@ -1,2 +1,2 @@
-export * from "./types.ts";
-export * from "./Parser.ts";
+export * from "./types.ts";
+export * from "./Parser.ts";

package/src/types.ts

@@ -1,244 +1,242 @@
-import {Tuple} from "./util.ts";
-
-export type Matrix4x4 = Tuple<number, 16>
-export type Vector2 = Tuple<number, 2>
-export type Vector3 = Tuple<number, 3>
-export type Vector4 = Tuple<number, 4>
-
-// ------------------------------- Scene -------------------------------
-
-export type Scene = {
-    /**
-     * All nodes in scene
-     */
-    nodes: Node[]
-    cameras: Camera[],
-    meshes: Mesh[],
-    skins: Skin[],
-}
-
-
-// ------------------------------- Node --------------------------------
-
-export type Node = {
-    transform: Matrix4x4,
-    name?: string,
-    children: Node[],
-    parent?: Node,
-} & ({ mesh: Mesh, skin?: undefined, camera?: undefined }
-    | { skin: Skin, mesh?: undefined, camera?: undefined }
-    | { camera: Camera, mesh?: undefined, skin?: undefined })
-
-
-// ------------------------------ Camera -------------------------------
-
-export type OrthographicCamera = {
-    type: "Orthographic"
-    xmag: number,
-    ymag: number,
-    zfar: number,
-    znear: number,
-    view: Matrix4x4,
-    projection: Matrix4x4,
-}
-
-export type PerspectiveCamera = {
-    type: "Perspective"
-    aspectRatio: number,
-    yfov: number,
-    zfar: number,
-    znear: number,
-    view: Matrix4x4,
-    projection: Matrix4x4,
-}
-
-export type Camera = OrthographicCamera | PerspectiveCamera
-
-
-// ------------------------------- Mesh --------------------------------
-
-export type MeshPrimitiveAttributes = {
-    positions: Vector3[],
-    uvs?: Vector2[],
-    normals?: Vector3[],
-    colors?: Vector4[]
-    weights?: Vector4[],
-    joints?: Vector4[],
-    tangents?: Vector4[], // TODO
-}
-
-export type MeshPrimitive = {
-    /**
-     * Vertex attributes of the mesh primitive
-     */
-    attributes: MeshPrimitiveAttributes,
-    indices?: Uint32Array,
-    material?: Material,
-}
-
-export type Mesh = {
-    primitives: MeshPrimitive[],
-    name?: string,
-}
-
-
-// -------------------------------- Skin -------------------------------
-
-export type Joint = {
-    name: string,
-    transform: Matrix4x4,
-    inverseBindTransform: Matrix4x4,
-    children: string[],
-    parent?: string,
-}
-
-export type Skin = {
-    root: Joint,
-    joints: Record<string, Joint>,
-    animations: Animation[],
-    globalInverseTransform: Matrix4x4,
-    name?: string,
-}
-
-// ----------------------------- Animation -----------------------------
-
-export type Animation = {
-    duration: number,
-    name?: string,
-    channels: Record<string, AnimationChannel>,
-}
-
-export type AnimationChannel = {
-    translation: AnimationKeyframe<Vector3>[]
-    rotation: AnimationKeyframe<Vector4>[]
-    scale: AnimationKeyframe<Vector3>[]
-}
-
-export type AnimationKeyframe<T> = { time: number, value: T }
-
-
-// ----------------------------- Texture -------------------------------
-
-// TODO: If source is undefined, don't create texture, if sampler is undefined create default sampler
-export type Texture = {
-    source: ImageBitmap,
-    sampler: Sampler,
-    name?: string,
-}
-
-export type Sampler = {
-    wrap: { s: TextureWrapMode, t: TextureWrapMode },
-    filter: { min: TextureMinFilter, mag: TextureMagFilter },
-}
-
-export type TextureMagFilter = "nearest" | "linear"
-
-export type TextureMinFilter =
-    "nearest"
-    | "linear"
-    | "nearest-mipmap-nearest"
-    | "linear-mipmap-nearest"
-    | "nearest-mipmap-linear"
-    | "linear-mipmap-linear"
-
-export type TextureWrapMode =
-    | "clamp-to-edge"
-    | "mirrored-repeat"
-    | "repeat"
-
-export const TextureWrapModeMap = {
-    [33071]: "clamp-to-edge",
-    [33648]: "mirrored-repeat",
-    [10497]: "repeat",
-} as const;
-
-export const TextureFilterMap = {
-    [9728]: "nearest",
-    [9729]: "linear",
-    [9984]: "nearest-mipmap-nearest",
-    [9985]: "linear-mipmap-nearest",
-    [9986]: "nearest-mipmap-linear",
-    [9987]: "linear-mipmap-linear",
-} as const;
-
-// ----------------------------- Material ------------------------------
-
-export type Material = {
-    metallicRoughness: MaterialMetallicRoughnessInfo,
-    normal?: MaterialNormalInfo,
-    emissive?: MaterialEmissiveInfo,
-    ambientOcclusion?: MaterialAmbientOcclusionInfo,
-    alpha: MaterialAlphaInfo,
-    /**
-     * Whether the material is double sided. Default is `false`.
-     */
-    doubleSided: boolean,
-}
-
-export type MaterialAlphaInfo = {
-    /**
-     * The alpha rendering mode of the material. Default is `"OPAQUE"`.
-     */
-    mode: "OPAQUE" | "MASK" | "BLEND",
-    /**
-     * The alpha cutoff value of the material. Default is `0.5`.
-     */
-    cutoff: number,
-}
-
-export type MaterialMetallicRoughnessInfo = {
-    /**
-     * The base color factor of the material. Default is `[1, 1, 1, 1]`.
-     */
-    baseColor: Vector4,
-    /**
-     * The base color texture of the material.
-     */
-    baseColorTexture?: Texture,
-    /**
-     * The factor for the metalness of the material. Default is `1`.
-     */
-    metallicFactor: number,
-    /**
-     * The factor for the roughness of the material. Default is `1`.
-     */
-    roughnessFactor: number,
-    /**
-     * The metallic roughness texture of the material.
-     */
-    metallicRoughnessTexture?: Texture,
-}
-
-export type MaterialNormalInfo = {
-    /**
-     * The normal texture of the material.
-     */
-    texture: Texture,
-    /**
-     * The scale applied to each vector of the normal map. Default is `1`.
-     */
-    scale: number,
-}
-
-export type MaterialEmissiveInfo = {
-    /**
-     * The emissive texture of the material.
-     */
-    texture: Texture,
-    /**
-     * The emissive factor of the material. Default is `[0, 0, 0]`.
-     */
-    factor: Vector3,
-}
-
-export type MaterialAmbientOcclusionInfo = {
-    /**
-     * The occlusion texture of the material.
-     */
-    texture: Texture,
-    /**
-     * The occlusion strength of the material. Default is `1`.
-     */
-    strength: number,
-}
-
+import {Tuple} from "./util.ts";
+
+export type Matrix4x4 = Tuple<number, 16>
+export type Vector2 = Tuple<number, 2>
+export type Vector3 = Tuple<number, 3>
+export type Vector4 = Tuple<number, 4>
+
+// ------------------------------- Scene -------------------------------
+
+export type Scene = {
+    /**
+     * All nodes in scene
+     */
+    nodes: Node[]
+    cameras: Camera[],
+    meshes: Mesh[],
+    skins: Skin[],
+}
+
+// ------------------------------- Node --------------------------------
+
+export type Node = {
+    transform: Matrix4x4,
+    name?: string,
+    children: Node[],
+    parent?: Node,
+} & (
+    | { mesh: Mesh, skin?: undefined, camera?: undefined }
+    | { skin: Skin, mesh?: undefined, camera?: undefined }
+    | { camera: Camera, mesh?: undefined, skin?: undefined }
+    )
+
+// ------------------------------ Camera -------------------------------
+
+export type OrthographicCamera = {
+    type: "Orthographic"
+    xmag: number,
+    ymag: number,
+    zfar: number,
+    znear: number,
+    view: Matrix4x4,
+    projection: Matrix4x4,
+}
+
+export type PerspectiveCamera = {
+    type: "Perspective"
+    aspectRatio: number,
+    yfov: number,
+    zfar: number,
+    znear: number,
+    view: Matrix4x4,
+    projection: Matrix4x4,
+}
+
+export type Camera = OrthographicCamera | PerspectiveCamera
+
+// ------------------------------- Mesh --------------------------------
+
+export type MeshPrimitiveAttributes = {
+    positions: Vector3[],
+    uvs?: Vector2[],
+    normals?: Vector3[],
+    colors?: Vector4[]
+    weights?: Vector4[],
+    joints?: Vector4[],
+    tangents?: Vector4[], // TODO
+}
+
+export type MeshPrimitive = {
+    /**
+     * Vertex attributes of the mesh primitive
+     */
+    attributes: MeshPrimitiveAttributes,
+    indices?: Uint32Array,
+    material?: Material,
+}
+
+export type Mesh = {
+    primitives: MeshPrimitive[],
+    name?: string,
+}
+
+// -------------------------------- Skin -------------------------------
+
+export type Joint = {
+    name: string,
+    transform: Matrix4x4,
+    inverseBindTransform: Matrix4x4,
+    children: string[],
+    parent?: string,
+}
+
+export type Skin = {
+    root: Joint,
+    joints: Record<string, Joint>,
+    animations: Animation[],
+    globalInverseTransform: Matrix4x4,
+    name?: string,
+}
+
+// ----------------------------- Animation -----------------------------
+
+export type Animation = {
+    duration: number,
+    name?: string,
+    channels: Record<string, AnimationChannel>,
+}
+
+export type AnimationChannel = {
+    translation: AnimationKeyframe<Vector3>[]
+    rotation: AnimationKeyframe<Vector4>[]
+    scale: AnimationKeyframe<Vector3>[]
+}
+
+export type AnimationKeyframe<T> = { time: number, value: T }
+
+// ----------------------------- Texture -------------------------------
+
+
+// TODO: If source is undefined, don't create texture, if sampler is undefined create default sampler
+export type Texture = {
+    source: ImageBitmap,
+    sampler: Sampler,
+    name?: string,
+}
+
+export type Sampler = {
+    wrap: { s: TextureWrapMode, t: TextureWrapMode },
+    filter: { min: TextureMinFilter, mag: TextureMagFilter },
+}
+
+export type TextureMagFilter = "nearest" | "linear"
+
+export type TextureMinFilter =
+    | "nearest"
+    | "linear"
+    | "nearest-mipmap-nearest"
+    | "linear-mipmap-nearest"
+    | "nearest-mipmap-linear"
+    | "linear-mipmap-linear"
+
+export type TextureWrapMode =
+    | "clamp-to-edge"
+    | "mirrored-repeat"
+    | "repeat"
+
+export const TextureWrapModeMap = {
+    [33071]: "clamp-to-edge",
+    [33648]: "mirrored-repeat",
+    [10497]: "repeat",
+} as const;
+
+export const TextureFilterMap = {
+    [9728]: "nearest",
+    [9729]: "linear",
+    [9984]: "nearest-mipmap-nearest",
+    [9985]: "linear-mipmap-nearest",
+    [9986]: "nearest-mipmap-linear",
+    [9987]: "linear-mipmap-linear",
+} as const;
+
+// ----------------------------- Material ------------------------------
+
+export type Material = {
+    metallicRoughness: MaterialMetallicRoughnessInfo,
+    normal?: MaterialNormalInfo,
+    emissive?: MaterialEmissiveInfo,
+    ambientOcclusion?: MaterialAmbientOcclusionInfo,
+    alpha: MaterialAlphaInfo,
+    /**
+     * Whether the material is double-sided. Default is `false`.
+     */
+    doubleSided: boolean,
+}
+
+export type MaterialAlphaInfo = {
+    /**
+     * The alpha rendering mode of the material. Default is `"OPAQUE"`.
+     */
+    mode: "OPAQUE" | "MASK" | "BLEND",
+    /**
+     * The alpha cutoff value of the material. Default is `0.5`.
+     */
+    cutoff: number,
+}
+
+export type MaterialMetallicRoughnessInfo = {
+    /**
+     * The base color factor of the material. Default is `[1, 1, 1, 1]`.
+     */
+    baseColor: Vector4,
+    /**
+     * The base color texture of the material.
+     */
+    baseColorTexture?: Texture,
+    /**
+     * The factor for the metalness of the material. Default is `1`.
+     */
+    metallicFactor: number,
+    /**
+     * The factor for the roughness of the material. Default is `1`.
+     */
+    roughnessFactor: number,
+    /**
+     * The metallic roughness texture of the material.
+     */
+    metallicRoughnessTexture?: Texture,
+}
+
+export type MaterialNormalInfo = {
+    /**
+     * The normal texture of the material.
+     */
+    texture: Texture,
+    /**
+     * The scale applied to each vector of the normal map. Default is `1`.
+     */
+    scale: number,
+}
+
+export type MaterialEmissiveInfo = {
+    /**
+     * The emissive texture of the material.
+     */
+    texture: Texture,
+
+    /**
+     * The emissive factor of the material. Default is `[0, 0, 0]`.
+     */
+    factor: Vector3,
+}
+
+export type MaterialAmbientOcclusionInfo = {
+    /**
+     * The occlusion texture of the material.
+     */
+    texture: Texture,
+    /**
+     * The occlusion strength of the material. Default is `1`.
+     */
+    strength: number,
+}

package/src/util.ts

@@ -1,67 +1,59 @@
-import {TransformOrder, mat4, vec3, quat, Matrix4} from "dom-game-math";
-import {Matrix4x4} from "./types.ts";
-
-// ----------------------------------- fail & assert -----------------------------------
-
-export function fail(msg: string): never {
-    throw new Error(msg);
-}
-
-export function assert(condition: boolean, msg: string): asserts condition {
-    if (!condition) {
-        throw new Error(msg);
-    }
-}
-
-// ------------------------------------- Accessor --------------------------------------
-
-export type AccessorArrayType =
-    | Float32ArrayConstructor
-    | Uint32ArrayConstructor
-    | Uint16ArrayConstructor
-    | Int16ArrayConstructor
-    | Uint8ArrayConstructor
-    | Int8ArrayConstructor
-
-export type AccessorConstructorType<T extends AccessorArrayType> = ReturnType<T["from"]>
-
-// --------------------------------------- Tuple ---------------------------------------
-
-export type Tuple<T, N extends number> = T[] & { length: N };
-
-export function chunk<T, N extends number>(array: Iterable<T>, size: N): Tuple<T, N>[] {
-    const result = new Array<T[]>;
-    let chunk = new Array<T>();
-
-    for (const value of Array.from(array)) {
-        chunk.push(value);
-        if (chunk.length === size) {
-            result.push(chunk);
-            chunk = [];
-        }
-    }
-
-    if (chunk.length) {
-        result.push(chunk);
-    }
-
-    return result as Tuple<T, N>[];
-}
-
-export function getTransform(transform: {
-    translation?: number[],
-    rotation?: number[],
-    scale?: number[]
-}, order: TransformOrder, out?: Tuple<number, 16>) {
-    out ??= Array.from(mat4.idt) as Tuple<number, 16>;
-
-    mat4.compose({
-        translation: transform.translation && vec3.fromArray(transform.translation),
-        rotation: transform.rotation && quat.fromArray(transform.rotation),
-        scale: transform.scale && vec3.fromArray(transform.scale),
-        order,
-    }, out as Matrix4);
-
-    return out;
-}
-
+import {TransformOrder, mat4, vec3, quat, Matrix4} from "dom-game-math";
+
+// ------------------------------------- Accessor --------------------------------------
+
+export type AccessorArrayType =
+    | Float32ArrayConstructor
+    | Uint32ArrayConstructor
+    | Uint16ArrayConstructor
+    | Int16ArrayConstructor
+    | Uint8ArrayConstructor
+    | Int8ArrayConstructor
+
+export type AccessorConstructorType<T extends AccessorArrayType> = ReturnType<T["from"]>
+
+// --------------------------------------- Tuple ---------------------------------------
+
+export type Tuple<T, N extends number> = T[] & { length: N };
+
+export function chunk<T, N extends number>(array: Iterable<T>, size: N): Tuple<T, N>[] {
+    const result = new Array<T[]>;
+    let chunk = new Array<T>();
+    
+    for (const value of Array.from(array)) {
+        chunk.push(value);
+        
+        if (chunk.length === size) {
+            result.push(chunk);
+            chunk = [];
+        }
+    }
+    
+    if (chunk.length) {
+        result.push(chunk);
+    }
+    
+    return result as Tuple<T, N>[];
+}
+
+export function getTransform(transform: {
+    translation?: number[],
+    rotation?: number[],
+    scale?: number[]
+}, order: TransformOrder, out?: Tuple<number, 16>) {
+    out ??= Array.from(mat4.idt) as Tuple<number, 16>;
+
+    mat4.compose({
+
+        translation: transform.translation && vec3.fromArray(transform.translation),
+
+        rotation: transform.rotation && quat.fromArray(transform.rotation),
+
+        scale: transform.scale && vec3.fromArray(transform.scale),
+
+        order,
+
+    }, out as Matrix4);
+    
+    return out;
+}

package/tsconfig.json

@@ -1,36 +1,35 @@
-{
-  "compilerOptions": {
-    "target": "ES2023",
-    "module": "ES2022",
-    "lib": [
-      "ES2023",
-      "DOM",
-      "DOM.Iterable"
-    ],
-    "useDefineForClassFields": true,
-    "skipLibCheck": true,
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "resolveJsonModule": true,
-    "isolatedModules": false,
-    "noEmit": true,
-    "noImplicitAny": false,
-    /* Linting */
-    "strict": true,
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noFallthroughCasesInSwitch": true,
-    "declaration": true,
-    "accessor-pairs": [
-      "error",
-      {
-        "setWithoutGet": true,
-        "getWithoutSet": true
-      }
-    ]
-  },
-  "include": [
-    "src"
-  ]
-}
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": [
+      "ESNext",
+      "DOM"
+    ],
+    "skipLibCheck": true,
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "noImplicitAny": false,
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+    "declaration": true,
+    "accessor-pairs": [
+      "error",
+      {
+        "setWithoutGet": true,
+        "getWithoutSet": true
+      }
+    ]
+  },
+  "include": [
+    "src"
+  ]
+}

package/.gitattributes

@@ -1,2 +0,0 @@
-# Auto detect text files and perform LF normalization
-* text=auto

package/gltf-importer.iml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="GENERAL_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="module" module-name="gltf-types" />
-  </component>
-</module>

package/index.html

@@ -1,14 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-    <!-- Get rid of "http://localhost:5173/favicon.ico not found" -->
-    <link rel="shortcut icon" href="#" />
-
-    <meta charset="UTF-8"/>
-    <script type="module" src="src/index.ts"></script>
-    <title></title>
-</head>
-<body>
-<canvas></canvas>
-</body>
-</html>