angular-three-postprocessing 2.0.0-beta.260 → 2.0.0-beta.262

package/lib/effect.d.ts

@@ -2,35 +2,35 @@ import { BlendFunction } from 'postprocessing';
 import * as i0 from "@angular/core";
 export declare const injectDefaultEffectOptions: {
     (): {
-        blendFunction?: BlendFunction | undefined;
-        opacity?: number | undefined;
+        blendFunction?: BlendFunction;
+        opacity?: number;
     };
     (injectOptions: import("@angular/core").InjectOptions & {
-        optional?: false | undefined;
+        optional?: false;
     } & {
-        injector?: import("@angular/core").Injector | undefined;
+        injector?: import("@angular/core").Injector;
     }): {
-        blendFunction?: BlendFunction | undefined;
-        opacity?: number | undefined;
+        blendFunction?: BlendFunction;
+        opacity?: number;
     };
     (injectOptions: import("@angular/core").InjectOptions & {
-        injector?: import("@angular/core").Injector | undefined;
+        injector?: import("@angular/core").Injector;
     }): {
-        blendFunction?: BlendFunction | undefined;
-        opacity?: number | undefined;
+        blendFunction?: BlendFunction;
+        opacity?: number;
     } | null;
 }, provideDefaultEffectOptions: ((value: {
-    blendFunction?: BlendFunction | undefined;
-    opacity?: number | undefined;
+    blendFunction?: BlendFunction;
+    opacity?: number;
 } | (() => {
-    blendFunction?: BlendFunction | undefined;
-    opacity?: number | undefined;
+    blendFunction?: BlendFunction;
+    opacity?: number;
 })) => import("@angular/core").Provider) & ((value: {
-    blendFunction?: BlendFunction | undefined;
-    opacity?: number | undefined;
+    blendFunction?: BlendFunction;
+    opacity?: number;
 } | (() => {
-    blendFunction?: BlendFunction | undefined;
-    opacity?: number | undefined;
+    blendFunction?: BlendFunction;
+    opacity?: number;
 })) => import("@angular/core").Provider);
 export declare class NgtpEffectBlendMode {
     effect: NgtpEffect | null;
@@ -39,14 +39,14 @@ export declare class NgtpEffectBlendMode {
 }
 export declare class NgtpEffect {
     defaultEffectOptions: {
-        blendFunction?: BlendFunction | undefined;
-        opacity?: number | undefined;
+        blendFunction?: BlendFunction;
+        opacity?: number;
     } | null;
     blendFunction: import("@angular/core").InputSignal<BlendFunction | undefined>;
     opacity: import("@angular/core").InputSignal<number | undefined>;
     private store;
     camera: import("@angular/core").Signal<import("angular-three").NgtCameraManual>;
-    invalidate: import("@angular/core").Signal<(frames?: number | undefined) => void>;
+    invalidate: import("@angular/core").Signal<(frames?: number) => void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpEffect, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgtpEffect, never, never, { "blendFunction": { "alias": "blendFunction"; "required": false; "isSignal": true; }; "opacity": { "alias": "opacity"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }

package/lib/effects/brightness-contrast.d.ts

@@ -6,9 +6,9 @@ export type BrightnessEffectOptions = NonNullable<ConstructorParameters<typeof B
 export declare class NgtpBrightnessContrast {
     effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<{
-        blendFunction?: import("postprocessing").BlendFunction | undefined;
-        brightness?: number | undefined;
-        contrast?: number | undefined;
+        blendFunction?: import("postprocessing").BlendFunction;
+        brightness?: number;
+        contrast?: number;
     }, "blendFunction">>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpBrightnessContrast, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtpBrightnessContrast, "ngtp-brightness-contrast", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;

package/lib/effects/chromatic-abberation.d.ts

@@ -6,8 +6,8 @@ export type ChromaticAberrationEffectOptions = Partial<NonNullable<ConstructorPa
 export declare class NgtpChromaticAberration {
     effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction | undefined;
-        offset?: import("three").Vector2 | undefined;
+        blendFunction?: import("postprocessing").BlendFunction;
+        offset?: import("three").Vector2;
         radialModulation: boolean;
         modulationOffset: number;
     }>, "blendFunction">>;

package/lib/effects/color-depth.d.ts

@@ -6,8 +6,8 @@ export type ColorDepthEffectOptions = Partial<NonNullable<ConstructorParameters<
 export declare class NgtpColorDepth {
     effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction | undefined;
-        bits?: number | undefined;
+        blendFunction?: import("postprocessing").BlendFunction;
+        bits?: number;
     }>, "blendFunction">>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpColorDepth, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtpColorDepth, "ngtp-color-depth", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;

package/lib/effects/depth.d.ts

@@ -6,8 +6,8 @@ export type DepthEffectOptions = Partial<NonNullable<ConstructorParameters<typeo
 export declare class NgtpDepth {
     effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction | undefined;
-        inverted?: boolean | undefined;
+        blendFunction?: import("postprocessing").BlendFunction;
+        inverted?: boolean;
     }>, "blendFunction">>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpDepth, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtpDepth, "ngtp-depth", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;

package/lib/effects/dot-screen.d.ts

@@ -6,9 +6,9 @@ export type DotScreenEffectOptions = Partial<NonNullable<ConstructorParameters<t
 export declare class NgtpDotScreen {
     effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction | undefined;
-        angle?: number | undefined;
-        scale?: number | undefined;
+        blendFunction?: import("postprocessing").BlendFunction;
+        angle?: number;
+        scale?: number;
     }>, "blendFunction">>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpDotScreen, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtpDotScreen, "ngtp-dot-screen", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;

package/lib/effects/fxaa.d.ts

@@ -6,7 +6,7 @@ export type FXAAEffectOptions = Partial<NonNullable<ConstructorParameters<typeof
 export declare class NgtpFXAA {
     effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction | undefined;
+        blendFunction?: import("postprocessing").BlendFunction;
     }>, "blendFunction">>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpFXAA, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtpFXAA, "ngtp-fxaa", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;

package/lib/effects/god-rays.d.ts

@@ -6,22 +6,22 @@ export declare class NgtpGodRays {
     private autoEffect;
     private effectComposer;
     options: import("@angular/core").InputSignal<{
-        blendFunction?: import("postprocessing").BlendFunction | undefined;
-        samples?: number | undefined;
-        density?: number | undefined;
-        decay?: number | undefined;
-        weight?: number | undefined;
-        exposure?: number | undefined;
-        clampMax?: number | undefined;
-        resolutionScale?: number | undefined;
-        resolutionX?: number | undefined;
-        resolutionY?: number | undefined;
-        width?: number | undefined;
-        height?: number | undefined;
-        kernelSize?: import("postprocessing").KernelSize | undefined;
-        blur?: boolean | undefined;
+        blendFunction?: import("postprocessing").BlendFunction;
+        samples?: number;
+        density?: number;
+        decay?: number;
+        weight?: number;
+        exposure?: number;
+        clampMax?: number;
+        resolutionScale?: number;
+        resolutionX?: number;
+        resolutionY?: number;
+        width?: number;
+        height?: number;
+        kernelSize?: import("postprocessing").KernelSize;
+        blur?: boolean;
     } & {
-        sun: Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | Points<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | ElementRef<Mesh<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap> | Points<import("three").BufferGeometry<import("three").NormalBufferAttributes>, import("three").Material | import("three").Material[], import("three").Object3DEventMap>>;
+        sun: Mesh | Points | ElementRef<Mesh | Points>;
     }>;
     effect: import("@angular/core").Signal<GodRaysEffect>;
     constructor();

package/lib/effects/hue-saturation.d.ts

@@ -6,9 +6,9 @@ export type HueSaturationEffectOptions = Partial<NonNullable<ConstructorParamete
 export declare class NgtpHueSaturation {
     effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction | undefined;
-        hue?: number | undefined;
-        saturation?: number | undefined;
+        blendFunction?: import("postprocessing").BlendFunction;
+        hue?: number;
+        saturation?: number;
     }>, "blendFunction">>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpHueSaturation, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtpHueSaturation, "ngtp-hue-saturation", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;

package/lib/effects/noise.d.ts

@@ -6,8 +6,8 @@ export type NoiseEffectOptions = Partial<NonNullable<ConstructorParameters<typeo
 export declare class NgtpNoise {
     effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: BlendFunction | undefined;
-        premultiply?: boolean | undefined;
+        blendFunction?: BlendFunction;
+        premultiply?: boolean;
     }>, "blendFunction">>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpNoise, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtpNoise, "ngtp-noise", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;

package/lib/effects/scanline.d.ts

@@ -6,11 +6,11 @@ export type ScanlineEffectOptions = Partial<NonNullable<ConstructorParameters<ty
 export declare class NgtpScanline {
     effect: NgtpEffect;
     options: import("@angular/core").InputSignalWithTransform<Omit<Partial<{
-        blendFunction?: BlendFunction | undefined;
-        density?: number | undefined;
+        blendFunction?: BlendFunction;
+        density?: number;
     }>, "blendFunction">, "" | Partial<Omit<Partial<{
-        blendFunction?: BlendFunction | undefined;
-        density?: number | undefined;
+        blendFunction?: BlendFunction;
+        density?: number;
     }>, "blendFunction">>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpScanline, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtpScanline, "ngtp-scanline", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;

package/lib/effects/sepia.d.ts

@@ -6,8 +6,8 @@ export type SepiaEffectOptions = Partial<NonNullable<ConstructorParameters<typeo
 export declare class NgtpSepia {
     effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction | undefined;
-        intensity?: number | undefined;
+        blendFunction?: import("postprocessing").BlendFunction;
+        intensity?: number;
     }>, "blendFunction">>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpSepia, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtpSepia, "ngtp-sepia", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;

package/lib/effects/smaa.d.ts

@@ -6,9 +6,9 @@ export type SMAAEffectOptions = Partial<NonNullable<ConstructorParameters<typeof
 export declare class NgtpSMAA {
     effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
-        preset?: import("postprocessing").SMAAPreset | undefined;
-        edgeDetectionMode?: import("postprocessing").EdgeDetectionMode | undefined;
-        predicationMode?: import("postprocessing").PredicationMode | undefined;
+        preset?: import("postprocessing").SMAAPreset;
+        edgeDetectionMode?: import("postprocessing").EdgeDetectionMode;
+        predicationMode?: import("postprocessing").PredicationMode;
     }>, "blendFunction">>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpSMAA, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtpSMAA, "ngtp-smaa", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;

package/lib/effects/tilt-shift.d.ts

@@ -6,16 +6,16 @@ export type TiltShiftEffectOptions = Partial<NonNullable<ConstructorParameters<t
 export declare class NgtpTiltShift {
     effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: BlendFunction | undefined;
-        offset?: number | undefined;
-        rotation?: number | undefined;
-        focusArea?: number | undefined;
-        feather?: number | undefined;
-        bias?: number | undefined;
-        kernelSize?: import("postprocessing").KernelSize | undefined;
-        resolutionScale?: number | undefined;
-        resolutionX?: number | undefined;
-        resolutionY?: number | undefined;
+        blendFunction?: BlendFunction;
+        offset?: number;
+        rotation?: number;
+        focusArea?: number;
+        feather?: number;
+        bias?: number;
+        kernelSize?: import("postprocessing").KernelSize;
+        resolutionScale?: number;
+        resolutionX?: number;
+        resolutionY?: number;
     }>, "blendFunction">>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpTiltShift, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtpTiltShift, "ngtp-tilt-shift", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;

package/lib/effects/vignette.d.ts

@@ -6,11 +6,11 @@ export type VignetteEffectOptions = Partial<NonNullable<ConstructorParameters<ty
 export declare class NgtpVignette {
     effect: NgtpEffect;
     options: import("@angular/core").InputSignal<Omit<Partial<{
-        blendFunction?: import("postprocessing").BlendFunction | undefined;
-        technique?: import("postprocessing").VignetteTechnique | undefined;
-        eskil?: boolean | undefined;
-        offset?: number | undefined;
-        darkness?: number | undefined;
+        blendFunction?: import("postprocessing").BlendFunction;
+        technique?: import("postprocessing").VignetteTechnique;
+        eskil?: boolean;
+        offset?: number;
+        darkness?: number;
     }>, "blendFunction">>;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgtpVignette, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<NgtpVignette, "ngtp-vignette", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof i1.NgtpEffect; inputs: { "blendFunction": "blendFunction"; "opacity": "opacity"; }; outputs: {}; }]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "angular-three-postprocessing",
-  "version": "2.0.0-beta.260",
+  "version": "2.0.0-beta.262",
   "publishConfig": {
     "access": "public"
   },
@@ -22,10 +22,9 @@
   ],
   "license": "MIT",
   "peerDependencies": {
-    "@angular/common": "^18.0.0",
-    "@angular/core": "^18.0.0",
+    "@angular/common": ">=18.0.0",
+    "@angular/core": ">=18.0.0",
     "maath": "^0.10.0",
-    "ngxtension": "^3.0.0",
     "postprocessing": "^6.0.0",
     "three": ">=0.148.0",
     "three-stdlib": "^2.0.0"