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

package/src/BlendEffect.test.ts

@@ -0,0 +1,24 @@
+import { AdvancedBlendMode } from './AdvancedBlendMode';
+import type { BlendEffect } from './BlendEffect';
+import type { RenderEffect } from './RenderEffect';
+
+describe('BlendEffect', () => {
+  it('is assignable to the open RenderEffect base with a BlendEffect kind', () => {
+    const effect: BlendEffect = {
+      kind: 'BlendEffect',
+      mode: AdvancedBlendMode.Overlay,
+      backdropKey: 'backdrop.scene',
+      opacity: 0.5,
+    };
+    const base: RenderEffect = effect;
+    expect(base.kind).toBe('BlendEffect');
+    expect(effect.mode).toBe('Overlay');
+    expect(effect.opacity).toBe(0.5);
+  });
+
+  it('leaves backdropKey and opacity optional', () => {
+    const effect: BlendEffect = { kind: 'BlendEffect', mode: AdvancedBlendMode.Hue };
+    expect(effect.backdropKey).toBeUndefined();
+    expect(effect.opacity).toBeUndefined();
+  });
+});

package/src/CompositeEffect.test.ts

@@ -0,0 +1,22 @@
+import type { CompositeEffect } from './CompositeEffect';
+import { CompositeOperator } from './CompositeOperator';
+import type { RenderEffect } from './RenderEffect';
+
+describe('CompositeEffect', () => {
+  it('is assignable to the open RenderEffect base with a CompositeEffect kind', () => {
+    const effect: CompositeEffect = {
+      kind: 'CompositeEffect',
+      operator: CompositeOperator.DestinationOut,
+      backdropKey: 'backdrop.scene',
+    };
+    const base: RenderEffect = effect;
+    expect(base.kind).toBe('CompositeEffect');
+    expect(effect.operator).toBe('DestinationOut');
+    expect(effect.backdropKey).toBe('backdrop.scene');
+  });
+
+  it('leaves backdropKey optional', () => {
+    const effect: CompositeEffect = { kind: 'CompositeEffect', operator: CompositeOperator.DestinationIn };
+    expect(effect.backdropKey).toBeUndefined();
+  });
+});

package/src/CompositeOperator.test.ts

@@ -0,0 +1,33 @@
+import { CompositeOperator } from './CompositeOperator';
+
+describe('CompositeOperator', () => {
+  it('carries canonical PascalCase values equal to their keys', () => {
+    expect(CompositeOperator.SourceOver).toBe('SourceOver');
+    expect(CompositeOperator.DestinationOut).toBe('DestinationOut');
+    expect(CompositeOperator.DestinationIn).toBe('DestinationIn');
+    expect(CompositeOperator.Xor).toBe('Xor');
+  });
+
+  it('covers the full Porter-Duff set', () => {
+    expect(Object.keys(CompositeOperator).sort()).toEqual(
+      [
+        'Clear',
+        'Copy',
+        'DestinationAtop',
+        'DestinationIn',
+        'DestinationOut',
+        'DestinationOver',
+        'SourceAtop',
+        'SourceIn',
+        'SourceOut',
+        'SourceOver',
+        'Xor',
+      ].sort(),
+    );
+  });
+
+  it('is a plain string a display node can hold as its composite intent', () => {
+    const operator: CompositeOperator = CompositeOperator.DestinationOut;
+    expect(operator).toBe('DestinationOut');
+  });
+});

package/src/CustomShaderMaterial.test.ts

@@ -0,0 +1,7 @@
+import { CustomShaderMaterialKind } from './CustomShaderMaterial';
+
+describe('CustomShaderMaterialKind', () => {
+  it('is the string CustomShaderMaterial', () => {
+    expect(CustomShaderMaterialKind).toBe('CustomShaderMaterial');
+  });
+});

package/src/DissolveModifier.test.ts

@@ -0,0 +1,27 @@
+import { DissolveModifierKind } from './DissolveModifier';
+import type { DissolveModifier } from './DissolveModifier';
+import type { Modifier } from './Modifier';
+
+describe('DissolveModifier', () => {
+  describe('DissolveModifierKind', () => {
+    it('is the canonical PascalCase type name', () => {
+      expect(DissolveModifierKind).toBe('DissolveModifier');
+    });
+  });
+
+  describe('descriptor shape', () => {
+    it('is assignable to the open Modifier base with slot Effect', () => {
+      const burn: DissolveModifier = {
+        kind: 'DissolveModifier',
+        slot: 'Effect',
+        threshold: 0.4,
+        edgeColor: 0xff6600ff,
+        edgeWidth: 0.05,
+        scale: 8,
+      };
+      const base: Modifier = burn;
+      expect(base.slot).toBe('Effect');
+      expect(burn.threshold).toBe(0.4);
+    });
+  });
+});

package/src/EmissiveModifier.test.ts

@@ -0,0 +1,34 @@
+import type { EmissiveModifier } from './EmissiveModifier';
+import { EmissiveModifierFacing, EmissiveModifierKind } from './EmissiveModifier';
+import type { Modifier } from './Modifier';
+
+describe('EmissiveModifier', () => {
+  describe('EmissiveModifierKind', () => {
+    it('is the canonical PascalCase type name', () => {
+      expect(EmissiveModifierKind).toBe('EmissiveModifier');
+    });
+  });
+
+  describe('EmissiveModifierFacing', () => {
+    it('names the facing gates as canonical PascalCase values', () => {
+      expect(EmissiveModifierFacing.Ignore).toBe('Ignore');
+      expect(EmissiveModifierFacing.AwayFromLight).toBe('AwayFromLight');
+      expect(EmissiveModifierFacing.TowardLight).toBe('TowardLight');
+    });
+  });
+
+  describe('descriptor shape', () => {
+    it('is assignable to the open Modifier base with slot Emissive', () => {
+      const nightSide: EmissiveModifier = {
+        kind: 'EmissiveModifier',
+        slot: 'Emissive',
+        color: 0xffdd88ff,
+        strength: 2,
+        facing: EmissiveModifierFacing.AwayFromLight,
+      };
+      const base: Modifier = nightSide;
+      expect(base.slot).toBe('Emissive');
+      expect(nightSide.color).toBe(0xffdd88ff);
+    });
+  });
+});

package/src/EnvReflectModifier.test.ts

@@ -0,0 +1,27 @@
+import { EnvReflectModifierKind } from './EnvReflectModifier';
+import type { EnvReflectModifier } from './EnvReflectModifier';
+import type { Modifier } from './Modifier';
+
+describe('EnvReflectModifier', () => {
+  describe('EnvReflectModifierKind', () => {
+    it('is the canonical PascalCase type name', () => {
+      expect(EnvReflectModifierKind).toBe('EnvReflectModifier');
+    });
+  });
+
+  describe('descriptor shape', () => {
+    it('is assignable to the open Modifier base with slot Effect', () => {
+      const chrome: EnvReflectModifier = {
+        kind: 'EnvReflectModifier',
+        slot: 'Effect',
+        tint: 0xffffffff,
+        intensity: 0.8,
+        fresnelBias: 0.04,
+        roughness: 0,
+      };
+      const base: Modifier = chrome;
+      expect(base.slot).toBe('Effect');
+      expect(chrome.intensity).toBe(0.8);
+    });
+  });
+});

package/src/FogModifier.test.ts

@@ -0,0 +1,34 @@
+import { FogModifierKind, FogModifierMode } from './FogModifier';
+import type { FogModifier } from './FogModifier';
+import type { Modifier } from './Modifier';
+
+describe('FogModifier', () => {
+  describe('FogModifierKind', () => {
+    it('is the canonical PascalCase type name', () => {
+      expect(FogModifierKind).toBe('FogModifier');
+    });
+  });
+
+  describe('FogModifierMode', () => {
+    it('names the distance-to-density curves as canonical PascalCase values', () => {
+      expect(FogModifierMode.Linear).toBe('Linear');
+      expect(FogModifierMode.Exponential).toBe('Exponential');
+      expect(FogModifierMode.Exponential2).toBe('Exponential2');
+    });
+  });
+
+  describe('descriptor shape', () => {
+    it('is assignable to the open Modifier base with slot Effect', () => {
+      const haze: FogModifier = {
+        kind: 'FogModifier',
+        slot: 'Effect',
+        color: 0xaabbccff,
+        mode: FogModifierMode.Exponential2,
+        density: 0.02,
+      };
+      const base: Modifier = haze;
+      expect(base.slot).toBe('Effect');
+      expect(haze.mode).toBe('Exponential2');
+    });
+  });
+});

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/BevelFilter.d.ts

@@ -1,17 +0,0 @@
-import type { BitmapFilter } from './BitmapFilter';
-export interface BevelFilter extends BitmapFilter {
-    readonly kind: 'BevelFilter';
-    readonly angle?: number;
-    readonly bevelType?: 'full' | 'inner' | 'outer';
-    readonly blurX?: number;
-    readonly blurY?: number;
-    readonly distance?: number;
-    readonly highlightAlpha?: number;
-    readonly highlightColor?: number;
-    readonly knockout?: boolean;
-    readonly quality?: number;
-    readonly shadowAlpha?: number;
-    readonly shadowColor?: number;
-    readonly strength?: number;
-}
-//# sourceMappingURL=BevelFilter.d.ts.map

package/dist/BevelFilter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BevelFilter.d.ts","sourceRoot":"","sources":["../src/BevelFilter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,MAAM,WAAW,WAAY,SAAQ,YAAY;IAC/C,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;IAChD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B"}

package/dist/BevelFilter.js

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

package/dist/BevelFilter.js.map

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

package/dist/BitmapFilter.d.ts

@@ -1,5 +0,0 @@
-import type { Kind } from './Entity';
-export interface BitmapFilter {
-    readonly kind: Kind;
-}
-//# sourceMappingURL=BitmapFilter.d.ts.map

package/dist/BitmapFilter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BitmapFilter.d.ts","sourceRoot":"","sources":["../src/BitmapFilter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAMrC,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;CACrB"}

package/dist/BitmapFilter.js

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

package/dist/BitmapFilter.js.map

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

package/dist/BitmapFilterMargin.d.ts

@@ -1,16 +0,0 @@
-/**
- * The per-side pixel margins a filter adds around the source bounds. Each side is the number of
- * pixels the filter may paint _beyond_ the source rectangle on that edge. Inner effects (inner
- * shadow, inner glow) never expand the bounds; all their fields are zero.
- */
-export interface BitmapFilterMargin {
-    /** Pixels added above the source rectangle. */
-    top: number;
-    /** Pixels added to the right of the source rectangle. */
-    right: number;
-    /** Pixels added below the source rectangle. */
-    bottom: number;
-    /** Pixels added to the left of the source rectangle. */
-    left: number;
-}
-//# sourceMappingURL=BitmapFilterMargin.d.ts.map

package/dist/BitmapFilterMargin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BitmapFilterMargin.d.ts","sourceRoot":"","sources":["../src/BitmapFilterMargin.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,+CAA+C;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAC;IACd,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;CACd"}

package/dist/BitmapFilterMargin.js

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

package/dist/BitmapFilterMargin.js.map

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

package/dist/BlurFilter.d.ts

@@ -1,7 +0,0 @@
-import type { BitmapFilter } from './BitmapFilter';
-export interface BlurFilter extends BitmapFilter {
-    readonly kind: 'BlurFilter';
-    readonly blurX?: number;
-    readonly blurY?: number;
-}
-//# sourceMappingURL=BlurFilter.d.ts.map

package/dist/BlurFilter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BlurFilter.d.ts","sourceRoot":"","sources":["../src/BlurFilter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,MAAM,WAAW,UAAW,SAAQ,YAAY;IAC9C,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB"}

package/dist/BlurFilter.js

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

package/dist/BlurFilter.js.map

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

package/dist/BrightnessContrastEffect.d.ts

@@ -1,7 +0,0 @@
-import type { RenderEffect } from './RenderEffect';
-export interface BrightnessContrastEffect extends RenderEffect {
-    kind: 'BrightnessContrastEffect';
-    brightness?: number;
-    contrast?: number;
-}
-//# sourceMappingURL=BrightnessContrastEffect.d.ts.map

package/dist/BrightnessContrastEffect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BrightnessContrastEffect.d.ts","sourceRoot":"","sources":["../src/BrightnessContrastEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,MAAM,WAAW,wBAAyB,SAAQ,YAAY;IAC5D,IAAI,EAAE,0BAA0B,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB"}