@designcombo/video 0.0.1 → 0.0.3

package/dist/effect/glsl/gl-effect.d.ts

@@ -0,0 +1,14 @@
+export interface GlTransition {
+    label: string;
+    fragment: string;
+    uniforms?: Record<string, {
+        value: any;
+        type: string;
+    }>;
+}
+export declare const GL_EFFECTS: Record<string, GlTransition>;
+export type EffectKey = keyof typeof GL_EFFECTS;
+export declare const GL_EFFECT_OPTIONS: Array<{
+    key: EffectKey;
+    label: string;
+}>;

package/dist/effect/types.d.ts

@@ -0,0 +1,24 @@
+import { Renderer, RenderTexture } from 'pixi.js';
+import { EffectKey } from './glsl/gl-effect';
+export interface EffectOptions {
+    name: EffectKey;
+    renderer: Renderer;
+}
+export interface EffectRendererOptions {
+    canvasTexture: HTMLCanvasElement | ImageBitmap | HTMLImageElement | HTMLVideoElement | RenderTexture;
+    progress: number;
+    width: number;
+    height: number;
+}
+export interface GLEffect {
+    author?: string;
+    createdAt?: string;
+    glsl: string;
+    license?: string;
+    name: EffectKey;
+    updatedAt?: string;
+    defaultParams?: any;
+    paramsTypes?: any;
+    fragment?: string;
+    label?: string;
+}

package/dist/effect/vertex.d.ts

@@ -0,0 +1 @@
+export declare const vertex = "\nin vec2 aPosition;\nout vec2 vTextureCoord;\n\nuniform vec4 uInputSize;\nuniform vec4 uOutputFrame;\nuniform vec4 uOutputTexture;\n\nvec4 filterVertexPosition( void )\n{\n    vec2 position = aPosition * uOutputFrame.zw + uOutputFrame.xy;\n\n    position.x = position.x * (2.0 / uOutputTexture.x) - 1.0;\n    position.y = position.y * (2.0*uOutputTexture.z / uOutputTexture.y) - uOutputTexture.z;\n\n    return vec4(position, 0.0, 1.0);\n}\n\nvec2 filterTextureCoord( void )\n{\n    return aPosition * (uOutputFrame.zw * uInputSize.zw);\n}\n\nvoid main(void)\n{\n    gl_Position = filterVertexPosition();\n    vTextureCoord = filterTextureCoord();\n}\n";

package/dist/event-emitter.d.ts

@@ -0,0 +1,47 @@
+export type EventType = string | symbol;
+export type Handler<T = unknown> = (event: T) => void;
+export type WildcardHandler<T = Record<string, unknown>> = (type: keyof T, event: T[keyof T]) => void;
+export type EventHandlerList<T = unknown> = Array<Handler<T>>;
+export type WildCardEventHandlerList<T = Record<string, unknown>> = Array<WildcardHandler<T>>;
+export type EventHandlerMap<Events extends Record<EventType, unknown>> = Map<keyof Events | '*', EventHandlerList<Events[keyof Events]> | WildCardEventHandlerList<Events>>;
+export interface Emitter<Events extends Record<EventType, unknown>> {
+    all: EventHandlerMap<Events>;
+    on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
+    on(type: '*', handler: WildcardHandler<Events>): void;
+    off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
+    off(type: '*', handler: WildcardHandler<Events>): void;
+    emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+    emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+}
+/**
+ * EventEmitter: A class-based event emitter for inheritance
+ */
+export default class EventEmitter<Events extends Record<EventType, unknown>> implements Emitter<Events> {
+    all: EventHandlerMap<Events>;
+    /**
+     * Register an event handler for the given type.
+     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
+     * @param {Function} handler Function to call in response to given event
+     */
+    on<Key extends keyof Events>(type: Key, handler: Handler<Events[Key]>): void;
+    on(type: '*', handler: WildcardHandler<Events>): void;
+    /**
+     * Remove an event handler for the given type.
+     * If `handler` is omitted, all handlers of the given type are removed.
+     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
+     * @param {Function} [handler] Handler function to remove
+     */
+    off<Key extends keyof Events>(type: Key, handler?: Handler<Events[Key]>): void;
+    off(type: '*', handler: WildcardHandler<Events>): void;
+    /**
+     * Invoke all handlers for the given type.
+     * If present, `'*'` handlers are invoked after type-matched handlers.
+     *
+     * Note: Manually firing '*' handlers is not supported.
+     *
+     * @param {string|symbol} type The event type to invoke
+     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
+     */
+    emit<Key extends keyof Events>(type: Key, event: Events[Key]): void;
+    emit<Key extends keyof Events>(type: undefined extends Events[Key] ? Key : never): void;
+}