@flighthq/types 0.2.0 → 0.2.1-next.410.a23f189

package/src/Modifier.test.ts

@@ -0,0 +1,48 @@
+import type { Modifier } from './Modifier';
+import { ModifierSlot } from './ModifierSlot';
+
+describe('Modifier', () => {
+  describe('open base contract', () => {
+    it('accepts a foreign custom modifier kind', () => {
+      interface AcmeModifier extends Modifier {
+        kind: 'acme.Dissolve';
+        threshold: number;
+      }
+
+      const modifier: AcmeModifier = {
+        kind: 'acme.Dissolve',
+        slot: ModifierSlot.Effect,
+        threshold: 0.5,
+      };
+      const base: Modifier = modifier;
+      expect(base.kind).toBe('acme.Dissolve');
+      expect(base.slot).toBe('Effect');
+    });
+
+    it('narrows on the kind discriminant', () => {
+      interface RedModifier extends Modifier {
+        kind: 'RedModifier';
+        strength: number;
+      }
+      interface BlueModifier extends Modifier {
+        kind: 'BlueModifier';
+        amount: number;
+      }
+
+      const mod: RedModifier | BlueModifier = {
+        kind: 'RedModifier',
+        slot: ModifierSlot.Diffuse,
+        strength: 2,
+      };
+      if (mod.kind === 'RedModifier') {
+        expectTypeOf(mod).toHaveProperty('strength');
+      }
+      expect(mod.kind).toBe('RedModifier');
+    });
+
+    it('accepts any string kind and slot', () => {
+      const modifier: Modifier = { kind: 'SomeModifier', slot: 'SomeSlot' };
+      expect(modifier.kind).toBe('SomeModifier');
+    });
+  });
+});

package/src/ModifierSlot.test.ts

@@ -0,0 +1,22 @@
+import { ModifierSlot } from './ModifierSlot';
+
+describe('ModifierSlot', () => {
+  it('exposes the slot taxonomy as canonical PascalCase values', () => {
+    expect(ModifierSlot.Vertex).toBe('Vertex');
+    expect(ModifierSlot.Diffuse).toBe('Diffuse');
+    expect(ModifierSlot.Specular).toBe('Specular');
+    expect(ModifierSlot.Normal).toBe('Normal');
+    expect(ModifierSlot.Emissive).toBe('Emissive');
+    expect(ModifierSlot.Effect).toBe('Effect');
+  });
+
+  it('is open — a vendor-prefixed slot satisfies the type', () => {
+    const custom: ModifierSlot = 'acme.Displacement';
+    expect(custom).toBe('acme.Displacement');
+  });
+
+  it('does not reserve ambient/shadow as active members in v1', () => {
+    expect((ModifierSlot as Record<string, string>).Ambient).toBeUndefined();
+    expect((ModifierSlot as Record<string, string>).Shadow).toBeUndefined();
+  });
+});

package/src/ResourceResolutionState.test.ts

@@ -0,0 +1,14 @@
+import { ResourceResolutionState } from './ResourceResolutionState';
+
+describe('ResourceResolutionState', () => {
+  it('names the four lifecycle states as canonical PascalCase values', () => {
+    expect(ResourceResolutionState.Unresolved).toBe('Unresolved');
+    expect(ResourceResolutionState.Loading).toBe('Loading');
+    expect(ResourceResolutionState.Resolved).toBe('Resolved');
+    expect(ResourceResolutionState.Failed).toBe('Failed');
+  });
+
+  it('is a closed four-member vocabulary', () => {
+    expect(Object.values(ResourceResolutionState).sort()).toEqual(['Failed', 'Loading', 'Resolved', 'Unresolved']);
+  });
+});

package/src/RimModifier.test.ts

@@ -0,0 +1,31 @@
+import type { Modifier } from './Modifier';
+import type { RimModifier } from './RimModifier';
+import { RimModifierKind } from './RimModifier';
+
+describe('RimModifier', () => {
+  describe('RimModifierKind', () => {
+    it('is the canonical PascalCase type name', () => {
+      expect(RimModifierKind).toBe('RimModifier');
+    });
+  });
+
+  describe('descriptor shape', () => {
+    it('is assignable to the open Modifier base with slot Effect', () => {
+      const atmosphere: RimModifier = {
+        kind: 'RimModifier',
+        slot: 'Effect',
+        color: 0x88bbffff,
+        power: 4,
+        intensity: 1.5,
+      };
+      const base: Modifier = atmosphere;
+      expect(base.slot).toBe('Effect');
+      expect(atmosphere.color).toBe(0x88bbffff);
+    });
+
+    it('allows the falloff params to be omitted (defaults live in the constructor)', () => {
+      const minimal: RimModifier = { kind: 'RimModifier', slot: 'Effect', color: 0xffffffff };
+      expect(minimal.power).toBeUndefined();
+    });
+  });
+});

package/src/SceneResourceRef.test.ts

@@ -0,0 +1,52 @@
+import { ResourceResolutionState } from './ResourceResolutionState';
+import type { EmbeddedSceneResourceRef, ExternalSceneResourceRef, SceneResourceRef } from './SceneResourceRef';
+import { SceneResourceRefKind } from './SceneResourceRef';
+
+describe('SceneResourceRef', () => {
+  describe('SceneResourceRefKind', () => {
+    it('names the two members as canonical PascalCase values', () => {
+      expect(SceneResourceRefKind.Embedded).toBe('Embedded');
+      expect(SceneResourceRefKind.External).toBe('External');
+    });
+  });
+
+  describe('descriptor shape', () => {
+    it('models an embedded ref carrying encoded bytes and a starting Unresolved state', () => {
+      const ref: EmbeddedSceneResourceRef = {
+        kind: 'Embedded',
+        bytes: new Uint8Array([0x89, 0x50, 0x4e, 0x47]),
+        mimeType: 'image/png',
+        state: ResourceResolutionState.Unresolved,
+      };
+      const base: SceneResourceRef = ref;
+      expect(base.kind).toBe('Embedded');
+      expect(ref.bytes.length).toBe(4);
+    });
+
+    it('models an external ref carrying a uri and optional basePath', () => {
+      const ref: ExternalSceneResourceRef = {
+        kind: 'External',
+        uri: 'textures/hull.png',
+        basePath: '/models/',
+        mimeType: null,
+        state: ResourceResolutionState.Unresolved,
+      };
+      const base: SceneResourceRef = ref;
+      expect(base.kind).toBe('External');
+      expect(ref.uri).toBe('textures/hull.png');
+    });
+
+    it('narrows on the kind discriminant', () => {
+      const ref: SceneResourceRef = {
+        kind: 'External',
+        uri: 'a.png',
+        basePath: null,
+        mimeType: null,
+        state: ResourceResolutionState.Loading,
+      };
+      if (ref.kind === 'External') {
+        expect(ref.uri).toBe('a.png');
+      }
+    });
+  });
+});

package/src/ShadedMaterial.test.ts

@@ -0,0 +1,70 @@
+import type { EmissiveModifier } from './EmissiveModifier';
+import { EntityRuntimeKey } from './Entity';
+import type { RimModifier } from './RimModifier';
+import type { ShadedMaterial } from './ShadedMaterial';
+import { ShadedMaterialKind } from './ShadedMaterial';
+import type { SurfaceMaterial } from './SurfaceMaterial';
+
+describe('ShadedMaterial', () => {
+  describe('ShadedMaterialKind', () => {
+    it('is the canonical PascalCase type name', () => {
+      expect(ShadedMaterialKind).toBe('ShadedMaterial');
+    });
+  });
+
+  describe('composable base material', () => {
+    it('carries an ordered modifier stack across slots', () => {
+      const emissive: EmissiveModifier = {
+        kind: 'EmissiveModifier',
+        slot: 'Emissive',
+        color: 0xffdd88ff,
+        strength: 2,
+      };
+      const rim: RimModifier = { kind: 'RimModifier', slot: 'Effect', color: 0x88bbffff };
+
+      const material: ShadedMaterial = {
+        [EntityRuntimeKey]: undefined,
+        kind: ShadedMaterialKind,
+        alphaCutoff: 0.5,
+        alphaMode: 'opaque',
+        alphaType: 'straight',
+        blendMode: 'Normal',
+        doubleSided: false,
+        diffuse: 0x334455ff,
+        diffuseMap: null,
+        normalMap: null,
+        normalScale: 1,
+        shininess: 32,
+        specular: 0xffffffff,
+        specularMap: null,
+        modifiers: [emissive, rim],
+      };
+
+      // Ordering is preserved for deterministic compilation.
+      expect(material.modifiers[0]?.slot).toBe('Emissive');
+      expect(material.modifiers[1]?.slot).toBe('Effect');
+    });
+
+    it('is a SurfaceMaterial (a lit surface over the shared trailer)', () => {
+      const material: ShadedMaterial = {
+        [EntityRuntimeKey]: undefined,
+        kind: ShadedMaterialKind,
+        alphaCutoff: 0,
+        alphaMode: 'blend',
+        alphaType: 'straight',
+        blendMode: 'Normal',
+        doubleSided: true,
+        diffuse: 0xffffffff,
+        diffuseMap: null,
+        normalMap: null,
+        normalScale: 1,
+        shininess: 16,
+        specular: 0x000000ff,
+        specularMap: null,
+        modifiers: [],
+      };
+      const surface: SurfaceMaterial = material;
+      expect(surface.kind).toBe('ShadedMaterial');
+    });
+  });
+});

package/src/SurfaceCompositeMode.test.ts

@@ -0,0 +1,21 @@
+import { SurfaceCompositeMode } from './SurfaceCompositeMode';
+
+describe('SurfaceCompositeMode', () => {
+  it('carries canonical PascalCase values equal to their keys', () => {
+    expect(SurfaceCompositeMode.Multiply).toBe('Multiply');
+    expect(SurfaceCompositeMode.DestinationOut).toBe('DestinationOut');
+    expect(SurfaceCompositeMode.Subtract).toBe('Subtract');
+    expect(SurfaceCompositeMode.Invert).toBe('Invert');
+  });
+
+  it('unifies both axes: color blends and Porter-Duff coverage operators', () => {
+    // A color blend and a coverage operator both live in the one vocabulary.
+    expect(SurfaceCompositeMode.Overlay).toBe('Overlay');
+    expect(SurfaceCompositeMode.DestinationIn).toBe('DestinationIn');
+  });
+
+  it('shares canonical string values so a GPU mode string is a valid SurfaceCompositeMode', () => {
+    const mode: SurfaceCompositeMode = 'Multiply';
+    expect(mode).toBe(SurfaceCompositeMode.Multiply);
+  });
+});

package/src/ToonModifier.test.ts

@@ -0,0 +1,25 @@
+import type { Modifier } from './Modifier';
+import { ToonModifierKind } from './ToonModifier';
+import type { ToonModifier } from './ToonModifier';
+
+describe('ToonModifier', () => {
+  describe('ToonModifierKind', () => {
+    it('is the canonical PascalCase type name', () => {
+      expect(ToonModifierKind).toBe('ToonModifier');
+    });
+  });
+
+  describe('descriptor shape', () => {
+    it('is assignable to the open Modifier base with slot Effect', () => {
+      const cel: ToonModifier = {
+        kind: 'ToonModifier',
+        slot: 'Effect',
+        steps: 3,
+        smoothness: 0.1,
+      };
+      const base: Modifier = cel;
+      expect(base.slot).toBe('Effect');
+      expect(cel.steps).toBe(3);
+    });
+  });
+});

package/src/VertexDisplaceModifier.test.ts

@@ -0,0 +1,35 @@
+import type { Modifier } from './Modifier';
+import { VertexDisplaceModifierKind, VertexDisplaceModifierSource } from './VertexDisplaceModifier';
+import type { VertexDisplaceModifier } from './VertexDisplaceModifier';
+
+describe('VertexDisplaceModifier', () => {
+  describe('VertexDisplaceModifierKind', () => {
+    it('is the canonical PascalCase type name', () => {
+      expect(VertexDisplaceModifierKind).toBe('VertexDisplaceModifier');
+    });
+  });
+
+  describe('VertexDisplaceModifierSource', () => {
+    it('names the displacement sources as canonical PascalCase values', () => {
+      expect(VertexDisplaceModifierSource.Sine).toBe('Sine');
+      expect(VertexDisplaceModifierSource.HeightMap).toBe('HeightMap');
+    });
+  });
+
+  describe('descriptor shape', () => {
+    it('is assignable to the open Modifier base with the vertex-stage slot', () => {
+      const flag: VertexDisplaceModifier = {
+        kind: 'VertexDisplaceModifier',
+        slot: 'Vertex',
+        source: VertexDisplaceModifierSource.Sine,
+        amplitude: 0.2,
+        frequency: 4,
+        speed: 2,
+        direction: { x: 1, y: 0, z: 0 },
+      };
+      const base: Modifier = flag;
+      expect(base.slot).toBe('Vertex');
+      expect(flag.amplitude).toBe(0.2);
+    });
+  });
+});

package/dist/Skeleton.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Skeleton.d.ts","sourceRoot":"","sources":["../src/Skeleton.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAW7C,MAAM,WAAW,QAAQ;IACvB,mBAAmB,EAAE,YAAY,CAAC;IAClC,aAAa,EAAE,YAAY,CAAC;IAC5B,MAAM,EAAE,SAAS,EAAE,CAAC;IAGpB,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;CAClC"}

package/dist/Skeleton.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Skeleton.js.map

package/dist/Skeleton.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Skeleton.js","sourceRoot":"","sources":["../src/Skeleton.ts"],"names":[],"mappings":""}

package/dist/SkeletonValidationDiagnostic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SkeletonValidationDiagnostic.d.ts","sourceRoot":"","sources":["../src/SkeletonValidationDiagnostic.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,MAAM,WAAW,4BAA4B;IAC3C,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,yBAAyB,EAAE,MAAM,CAAC;IAClC,2FAA2F;IAC3F,iCAAiC,EAAE,MAAM,CAAC;IAC1C,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/dist/SkeletonValidationDiagnostic.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=SkeletonValidationDiagnostic.js.map

package/dist/SkeletonValidationDiagnostic.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SkeletonValidationDiagnostic.js","sourceRoot":"","sources":["../src/SkeletonValidationDiagnostic.ts"],"names":[],"mappings":""}