buninu-browser 0.0.2

package/vendor/happy-dom/packages/happy-dom/src/animation/Animation.ts

@@ -0,0 +1,273 @@
+import * as PropertySymbol from '../PropertySymbol.js';
+import EventTarget from '../event/EventTarget.js';
+import type Event from '../event/Event.js';
+import type AnimationTimeline from './AnimationTimeline.js';
+import type KeyframeEffect from './KeyframeEffect.js';
+import type BrowserWindow from '../window/BrowserWindow.js';
+import DOMExceptionNameEnum from '../exception/DOMExceptionNameEnum.js';
+
+export type TAnimationPlayState = 'finished' | 'idle' | 'paused' | 'running';
+export type TAnimationReplaceState = 'active' | 'persisted' | 'removed';
+
+/**
+ * Animation.
+ *
+ * @see https://drafts.csswg.org/web-animations-1/#the-animation-interface
+ */
+export default class Animation extends EventTarget {
+	// Injected by WindowContextClassExtender
+	protected declare [PropertySymbol.window]: BrowserWindow;
+
+	public id = '';
+	public effect: KeyframeEffect | null;
+	public timeline: AnimationTimeline | null;
+	public startTime: number | null = null;
+	public playbackRate = 1;
+	public replaceState: TAnimationReplaceState = 'active';
+	public ready: Promise<this>;
+	public finished: Promise<this>;
+	#playState: TAnimationPlayState = 'idle';
+	#currentTime: number | null = null;
+	#timer: NodeJS.Timeout | null = null;
+	#resolveFinished: ((animation: this) => void) | null = null;
+	#rejectFinished: ((reason: unknown) => void) | null = null;
+	public [PropertySymbol.propertyEventListeners]: Map<string, ((event: Event) => void) | null> =
+		new Map();
+
+	/**
+	 * Constructor.
+	 *
+	 * @param effect Animation effect.
+	 * @param timeline Animation timeline.
+	 */
+	constructor(effect: KeyframeEffect | null = null, timeline?: AnimationTimeline | null) {
+		super();
+		this.effect = effect;
+		this.timeline =
+			timeline === undefined ? this[PropertySymbol.window].document.timeline : timeline;
+		this.ready = Promise.resolve(this);
+		this.finished = this.#createFinishedPromise();
+	}
+
+	// Events
+
+	/* eslint-disable jsdoc/require-jsdoc */
+
+	public get oncancel(): ((event: Event) => void) | null {
+		return this[PropertySymbol.propertyEventListeners].get('oncancel') ?? null;
+	}
+
+	public set oncancel(value: ((event: Event) => void) | null) {
+		this[PropertySymbol.propertyEventListeners].set('oncancel', value);
+	}
+
+	public get onfinish(): ((event: Event) => void) | null {
+		return this[PropertySymbol.propertyEventListeners].get('onfinish') ?? null;
+	}
+
+	public set onfinish(value: ((event: Event) => void) | null) {
+		this[PropertySymbol.propertyEventListeners].set('onfinish', value);
+	}
+
+	public get onremove(): ((event: Event) => void) | null {
+		return this[PropertySymbol.propertyEventListeners].get('onremove') ?? null;
+	}
+
+	public set onremove(value: ((event: Event) => void) | null) {
+		this[PropertySymbol.propertyEventListeners].set('onremove', value);
+	}
+
+	/* eslint-enable jsdoc/require-jsdoc */
+
+	/**
+	 * Returns the current time.
+	 *
+	 * @returns Current time.
+	 */
+	public get currentTime(): number | null {
+		const timelineTime = this.timeline?.currentTime;
+		if (this.#playState === 'running' && this.startTime !== null && timelineTime != null) {
+			return (timelineTime - this.startTime) * this.playbackRate;
+		}
+		return this.#currentTime;
+	}
+
+	/**
+	 * Sets the current time.
+	 *
+	 * @param value Current time.
+	 */
+	public set currentTime(value: number | null) {
+		this.#currentTime = value;
+		const timelineTime = this.timeline?.currentTime;
+		if (value !== null && timelineTime != null && this.playbackRate !== 0) {
+			this.startTime = timelineTime - value / this.playbackRate;
+		}
+		if (this.#playState === 'running') {
+			this.#scheduleFinish();
+		}
+	}
+
+	/**
+	 * Returns the play state.
+	 *
+	 * @returns Play state.
+	 */
+	public get playState(): TAnimationPlayState {
+		return this.#playState;
+	}
+
+	/**
+	 * Returns whether a play or pause task is pending.
+	 *
+	 * @returns Pending state.
+	 */
+	public get pending(): boolean {
+		return false;
+	}
+
+	/**
+	 * Starts or resumes playback.
+	 */
+	public play(): void {
+		if (this.#playState === 'finished' || this.#playState === 'idle') {
+			this.finished = this.#createFinishedPromise();
+		}
+		const currentTime = this.#currentTime ?? (this.playbackRate < 0 ? this.#getEndTime() : 0);
+		this.#currentTime = currentTime;
+		const timelineTime = this.timeline?.currentTime;
+		if (timelineTime != null && this.playbackRate !== 0) {
+			this.startTime = timelineTime - currentTime / this.playbackRate;
+		}
+		this.#playState = 'running';
+		this.#scheduleFinish();
+	}
+
+	/**
+	 * Pauses playback.
+	 */
+	public pause(): void {
+		if (this.#playState === 'running') {
+			this.#currentTime = this.currentTime;
+			this.startTime = null;
+			this.#playState = 'paused';
+			this.#clearTimer();
+		}
+	}
+
+	/**
+	 * Reverses playback.
+	 */
+	public reverse(): void {
+		this.playbackRate = this.playbackRate === 0 ? -1 : -this.playbackRate;
+		this.play();
+	}
+
+	/**
+	 * Finishes playback.
+	 */
+	public finish(): void {
+		if (this.playbackRate === 0) {
+			throw new this[PropertySymbol.window].DOMException(
+				'The animation playback rate is zero.',
+				DOMExceptionNameEnum.invalidStateError
+			);
+		}
+		this.#clearTimer();
+		this.#currentTime = this.playbackRate < 0 ? 0 : this.#getEndTime();
+		this.startTime = null;
+		this.#playState = 'finished';
+		this.#resolveFinished?.(this);
+		this.dispatchEvent(new this[PropertySymbol.window].Event('finish'));
+	}
+
+	/**
+	 * Cancels playback.
+	 */
+	public cancel(): void {
+		if (this.#playState === 'idle') {
+			return;
+		}
+		this.#clearTimer();
+		this.#playState = 'idle';
+		this.#currentTime = null;
+		this.startTime = null;
+		this.#rejectFinished?.(
+			new this[PropertySymbol.window].DOMException(
+				'The animation was canceled.',
+				DOMExceptionNameEnum.abortError
+			)
+		);
+		this.dispatchEvent(new this[PropertySymbol.window].Event('cancel'));
+	}
+
+	/**
+	 * Persists the animation.
+	 */
+	public persist(): void {
+		this.replaceState = 'persisted';
+	}
+
+	/**
+	 * Updates the playback rate.
+	 *
+	 * @param playbackRate Playback rate.
+	 */
+	public updatePlaybackRate(playbackRate: number): void {
+		const currentTime = this.currentTime;
+		this.playbackRate = playbackRate;
+		this.currentTime = currentTime;
+	}
+
+	/**
+	 * Gets the end time of the animation.
+	 *
+	 * @returns End time.
+	 */
+	#getEndTime(): number {
+		return this.effect?.getComputedTiming().endTime ?? 0;
+	}
+
+	/**
+	 * Creates a new finished promise.
+	 *
+	 * @returns Finished promise.
+	 */
+	#createFinishedPromise(): Promise<this> {
+		return new Promise<this>((resolve, reject) => {
+			this.#resolveFinished = resolve;
+			this.#rejectFinished = reject;
+		});
+	}
+
+	/**
+	 * Schedules the finish of the animation.
+	 */
+	#scheduleFinish(): void {
+		this.#clearTimer();
+		if (!this.effect || this.playbackRate === 0) {
+			return;
+		}
+		const currentTime = this.currentTime ?? 0;
+		const remaining =
+			this.playbackRate < 0
+				? currentTime / -this.playbackRate
+				: (this.#getEndTime() - currentTime) / this.playbackRate;
+		if (Number.isFinite(remaining)) {
+			this.#timer = this[PropertySymbol.window].setTimeout(
+				() => this.finish(),
+				Math.max(0, remaining)
+			);
+		}
+	}
+
+	/**
+	 * Clears the finish timer.
+	 */
+	#clearTimer(): void {
+		if (this.#timer !== null) {
+			this[PropertySymbol.window].clearTimeout(this.#timer);
+			this.#timer = null;
+		}
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/animation/AnimationTimeline.ts

@@ -0,0 +1,15 @@
+/**
+ * Animation timeline.
+ *
+ * @see https://drafts.csswg.org/web-animations-1/#the-animationtimeline-interface
+ */
+export default class AnimationTimeline {
+	/**
+	 * Returns the current timeline time.
+	 *
+	 * @returns Current time in milliseconds.
+	 */
+	public get currentTime(): number | null {
+		return null;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/animation/DocumentTimeline.ts

@@ -0,0 +1,33 @@
+import AnimationTimeline from './AnimationTimeline.js';
+
+export interface IDocumentTimelineOptions {
+	originTime?: number;
+}
+
+/**
+ * Document timeline.
+ *
+ * @see https://drafts.csswg.org/web-animations-1/#the-documenttimeline-interface
+ */
+export default class DocumentTimeline extends AnimationTimeline {
+	#originTime: number;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param options Options.
+	 */
+	constructor(options: IDocumentTimelineOptions = {}) {
+		super();
+		this.#originTime = options.originTime ?? 0;
+	}
+
+	/**
+	 * Returns the current timeline time.
+	 *
+	 * @returns Current time in milliseconds.
+	 */
+	public override get currentTime(): number {
+		return performance.now() - this.#originTime;
+	}
+}

package/vendor/happy-dom/packages/happy-dom/src/animation/KeyframeEffect.ts

@@ -0,0 +1,295 @@
+import type Element from '../nodes/element/Element.js';
+
+export type TCompositeOperation = 'accumulate' | 'add' | 'replace';
+export type TKeyframeCompositeOperation = 'accumulate' | 'add' | 'auto' | 'replace';
+export type TIterationCompositeOperation = 'accumulate' | 'replace';
+export type TPlaybackDirection = 'alternate' | 'alternate-reverse' | 'normal' | 'reverse';
+export type TFillMode = 'auto' | 'backwards' | 'both' | 'forwards' | 'none';
+export type TKeyframeValue = string | number | null;
+import * as PropertySymbol from '../PropertySymbol.js';
+import type BrowserWindow from '../window/BrowserWindow.js';
+
+export interface IKeyframe {
+	[property: string]: TKeyframeValue | undefined;
+	composite?: TKeyframeCompositeOperation;
+	easing?: string;
+	offset?: number | null;
+}
+
+export interface IPropertyIndexedKeyframes {
+	[property: string]: TKeyframeValue | TKeyframeValue[] | undefined;
+	composite?: TKeyframeCompositeOperation | TKeyframeCompositeOperation[];
+	easing?: string | string[];
+	offset?: number | null | Array<number | null>;
+}
+
+export interface IComputedKeyframe {
+	[property: string]: string | number | null;
+	composite: TKeyframeCompositeOperation;
+	computedOffset: number;
+	easing: string;
+	offset: number | null;
+}
+
+export interface IEffectTiming {
+	delay?: number;
+	direction?: TPlaybackDirection;
+	duration?: number | 'auto';
+	easing?: string;
+	endDelay?: number;
+	fill?: TFillMode;
+	iterationStart?: number;
+	iterations?: number;
+}
+
+export interface IKeyframeEffectOptions extends IEffectTiming {
+	composite?: TCompositeOperation;
+	iterationComposite?: TIterationCompositeOperation;
+}
+
+export interface IComputedEffectTiming extends Required<IEffectTiming> {
+	activeDuration: number;
+	currentIteration: number | null;
+	endTime: number;
+	localTime: number | null;
+	progress: number | null;
+}
+
+/**
+ * Keyframe effect.
+ *
+ * @see https://drafts.csswg.org/web-animations-1/#the-keyframeeffect-interface
+ */
+export default class KeyframeEffect {
+	// Injected by WindowContextClassExtender
+	protected declare [PropertySymbol.window]: BrowserWindow;
+
+	public target: Element | null;
+	public pseudoElement: string | null = null;
+	public composite: TCompositeOperation;
+	public iterationComposite: TIterationCompositeOperation;
+	#keyframes: IComputedKeyframe[];
+	#timing: Required<IEffectTiming>;
+
+	/**
+	 * Constructor.
+	 *
+	 * @param target Target element.
+	 * @param keyframes Keyframes.
+	 * @param options Timing options.
+	 */
+	constructor(
+		target: Element | null,
+		keyframes: IKeyframe[] | IPropertyIndexedKeyframes | null,
+		options: number | IKeyframeEffectOptions = {}
+	) {
+		this.target = target;
+		this.#keyframes = this.#processKeyframes(keyframes);
+		this.#timing = this.#processTiming(options);
+		this.composite = typeof options === 'number' ? 'replace' : (options.composite ?? 'replace');
+		this.iterationComposite =
+			typeof options === 'number' ? 'replace' : (options.iterationComposite ?? 'replace');
+	}
+
+	/**
+	 * Returns the timing properties.
+	 *
+	 * @returns Timing properties.
+	 */
+	public getTiming(): Required<IEffectTiming> {
+		return { ...this.#timing };
+	}
+
+	/**
+	 * Returns computed timing properties.
+	 *
+	 * @returns Computed timing properties.
+	 */
+	public getComputedTiming(): IComputedEffectTiming {
+		const duration = this.#timing.duration === 'auto' ? 0 : this.#timing.duration;
+		const activeDuration = duration * this.#timing.iterations;
+		return {
+			...this.#timing,
+			activeDuration,
+			currentIteration: null,
+			endTime: Math.max(0, this.#timing.delay + activeDuration + this.#timing.endDelay),
+			localTime: null,
+			progress: null
+		};
+	}
+
+	/**
+	 * Updates timing properties.
+	 *
+	 * @param timing Timing properties.
+	 */
+	public updateTiming(timing: IEffectTiming = {}): void {
+		this.#timing = this.#processTiming({ ...this.#timing, ...timing });
+	}
+
+	/**
+	 * Returns computed keyframes.
+	 *
+	 * @returns Keyframes.
+	 */
+	public getKeyframes(): IComputedKeyframe[] {
+		return this.#keyframes.map((keyframe) => ({ ...keyframe }));
+	}
+
+	/**
+	 * Replaces the keyframes.
+	 *
+	 * @param keyframes Keyframes.
+	 */
+	public setKeyframes(keyframes: IKeyframe[] | IPropertyIndexedKeyframes | null): void {
+		this.#keyframes = this.#processKeyframes(keyframes);
+	}
+
+	/**
+	 *
+	 * @param options
+	 */
+	#processTiming(options: number | IEffectTiming): Required<IEffectTiming> {
+		const timing = typeof options === 'number' ? { duration: options } : options;
+		const duration = timing.duration ?? 'auto';
+		const iterations = timing.iterations ?? 1;
+		if ((duration !== 'auto' && (!Number.isFinite(duration) || duration < 0)) || iterations < 0) {
+			throw new this[PropertySymbol.window].TypeError('Invalid animation timing options.');
+		}
+		return {
+			delay: timing.delay ?? 0,
+			direction: timing.direction ?? 'normal',
+			duration,
+			easing: timing.easing ?? 'linear',
+			endDelay: timing.endDelay ?? 0,
+			fill: timing.fill ?? 'auto',
+			iterationStart: timing.iterationStart ?? 0,
+			iterations
+		};
+	}
+
+	/**
+	 *
+	 * @param keyframes
+	 */
+	#processKeyframes(
+		keyframes: IKeyframe[] | IPropertyIndexedKeyframes | null
+	): IComputedKeyframe[] {
+		if (!keyframes) {
+			return [];
+		}
+		if (Array.isArray(keyframes)) {
+			const processed = keyframes.map((keyframe) => this.#processKeyframe(keyframe));
+			this.#computeOffsets(processed);
+			return processed;
+		}
+
+		const propertyNames = Object.keys(keyframes).filter(
+			(property) => !['composite', 'easing', 'offset'].includes(property)
+		);
+		const length = Math.max(
+			0,
+			...['composite', 'easing', 'offset'].map((property) =>
+				Array.isArray(keyframes[property]) ? keyframes[property].length : 0
+			),
+			...propertyNames.map((property) =>
+				Array.isArray(keyframes[property]) ? keyframes[property].length : 1
+			)
+		);
+		const offsets = Array.isArray(keyframes.offset) ? keyframes.offset : [keyframes.offset ?? null];
+		const easings = Array.isArray(keyframes.easing)
+			? keyframes.easing
+			: [keyframes.easing ?? 'linear'];
+		const composites = Array.isArray(keyframes.composite)
+			? keyframes.composite
+			: [keyframes.composite ?? 'auto'];
+		const processed: IComputedKeyframe[] = Array.from({ length }, (_, index) => ({
+			offset: offsets[index] ?? null,
+			easing: easings[index] ?? 'linear',
+			composite: composites[index] ?? 'auto',
+			computedOffset: 0
+		}));
+		for (const property of propertyNames) {
+			const values = Array.isArray(keyframes[property])
+				? keyframes[property]
+				: [<TKeyframeValue>keyframes[property]];
+			for (let index = 0; index < values.length; index++) {
+				if (values[index] !== undefined) {
+					processed[index][property] = String(values[index]);
+				}
+			}
+		}
+		this.#computeOffsets(processed);
+		return processed;
+	}
+
+	/**
+	 * Processes a keyframe.
+	 *
+	 * @param keyframe Keyframe.
+	 * @returns Computed keyframe.
+	 */
+	#processKeyframe(keyframe: IKeyframe): IComputedKeyframe {
+		const processed: IComputedKeyframe = {
+			offset: keyframe.offset ?? null,
+			easing: keyframe.easing ?? 'linear',
+			composite: keyframe.composite ?? 'auto',
+			computedOffset: 0
+		};
+		for (const property of Object.keys(keyframe)) {
+			if (
+				!['composite', 'easing', 'offset'].includes(property) &&
+				keyframe[property] !== undefined
+			) {
+				processed[property] = String(keyframe[property]);
+			}
+		}
+		return processed;
+	}
+
+	/**
+	 *
+	 * @param keyframes
+	 */
+	#computeOffsets(keyframes: IComputedKeyframe[]): void {
+		let previousOffset = -Infinity;
+		for (const keyframe of keyframes) {
+			if (keyframe.offset !== null && keyframe.offset !== undefined) {
+				if (keyframe.offset < previousOffset || keyframe.offset < 0 || keyframe.offset > 1) {
+					throw new this[PropertySymbol.window].TypeError(
+						'Keyframe offsets must be in non-decreasing order between 0 and 1.'
+					);
+				}
+				previousOffset = keyframe.offset;
+			}
+		}
+		if (!keyframes.length) {
+			return;
+		}
+		const computedOffsets = keyframes.map((keyframe) => keyframe.offset);
+		if (computedOffsets[0] === null) {
+			computedOffsets[0] = keyframes.length === 1 ? 1 : 0;
+		}
+		if (computedOffsets.at(-1) === null) {
+			computedOffsets[computedOffsets.length - 1] = 1;
+		}
+		let startIndex = 0;
+		while (startIndex < computedOffsets.length - 1) {
+			let endIndex = startIndex + 1;
+			while (computedOffsets[endIndex] === null) {
+				endIndex++;
+			}
+			const startOffset = <number>computedOffsets[startIndex];
+			const endOffset = <number>computedOffsets[endIndex];
+			for (let index = startIndex + 1; index < endIndex; index++) {
+				computedOffsets[index] =
+					startOffset +
+					((endOffset - startOffset) * (index - startIndex)) / (endIndex - startIndex);
+			}
+			startIndex = endIndex;
+		}
+		for (let index = 0; index < keyframes.length; index++) {
+			keyframes[index].computedOffset = <number>computedOffsets[index];
+		}
+	}
+}