/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { DOCUMENT } from '@angular/common';
import { ANIMATION_MODULE_TYPE, Inject, inject, Injectable, RendererFactory2, ViewEncapsulation, ɵRuntimeError as RuntimeError, } from '@angular/core';
import { sequence } from './animation_metadata';
import * as i0 from "@angular/core";
/**
 * An injectable service that produces an animation sequence programmatically within an
 * Angular component or directive.
 * Provided by the `BrowserAnimationsModule` or `NoopAnimationsModule`.
 *
 * @usageNotes
 *
 * To use this service, add it to your component or directive as a dependency.
 * The service is instantiated along with your component.
 *
 * Apps do not typically need to create their own animation players, but if you
 * do need to, follow these steps:
 *
 * 1. Use the <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code> method
 * to create a programmatic animation. The method returns an `AnimationFactory` instance.
 *
 * 2. Use the factory object to create an `AnimationPlayer` and attach it to a DOM element.
 *
 * 3. Use the player object to control the animation programmatically.
 *
 * For example:
 *
 * ```ts
 * // import the service from BrowserAnimationsModule
 * import {AnimationBuilder} from '@angular/animations';
 * // require the service as a dependency
 * class MyCmp {
 *   constructor(private _builder: AnimationBuilder) {}
 *
 *   makeAnimation(element: any) {
 *     // first define a reusable animation
 *     const myAnimation = this._builder.build([
 *       style({ width: 0 }),
 *       animate(1000, style({ width: '100px' }))
 *     ]);
 *
 *     // use the returned factory object to create a player
 *     const player = myAnimation.create(element);
 *
 *     player.play();
 *   }
 * }
 * ```
 *
 * @publicApi
 */
export class AnimationBuilder {
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AnimationBuilder, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AnimationBuilder, providedIn: 'root', useFactory: () => inject(BrowserAnimationBuilder) }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: AnimationBuilder, decorators: [{
            type: Injectable,
            args: [{ providedIn: 'root', useFactory: () => inject(BrowserAnimationBuilder) }]
        }] });
/**
 * A factory object returned from the
 * <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code>
 * method.
 *
 * @publicApi
 */
export class AnimationFactory {
}
export class BrowserAnimationBuilder extends AnimationBuilder {
    constructor(rootRenderer, doc) {
        super();
        this.animationModuleType = inject(ANIMATION_MODULE_TYPE, { optional: true });
        this._nextAnimationId = 0;
        const typeData = {
            id: '0',
            encapsulation: ViewEncapsulation.None,
            styles: [],
            data: { animation: [] },
        };
        this._renderer = rootRenderer.createRenderer(doc.body, typeData);
        if (this.animationModuleType === null && !isAnimationRenderer(this._renderer)) {
            // We only support AnimationRenderer & DynamicDelegationRenderer for this AnimationBuilder
            throw new RuntimeError(3600 /* RuntimeErrorCode.BROWSER_ANIMATION_BUILDER_INJECTED_WITHOUT_ANIMATIONS */, (typeof ngDevMode === 'undefined' || ngDevMode) &&
                'Angular detected that the `AnimationBuilder` was injected, but animation support was not enabled. ' +
                    'Please make sure that you enable animations in your application by calling `provideAnimations()` or `provideAnimationsAsync()` function.');
        }
    }
    build(animation) {
        const id = this._nextAnimationId;
        this._nextAnimationId++;
        const entry = Array.isArray(animation) ? sequence(animation) : animation;
        issueAnimationCommand(this._renderer, null, id, 'register', [entry]);
        return new BrowserAnimationFactory(id, this._renderer);
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: BrowserAnimationBuilder, deps: [{ token: i0.RendererFactory2 }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable }); }
    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: BrowserAnimationBuilder, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.3", ngImport: i0, type: BrowserAnimationBuilder, decorators: [{
            type: Injectable,
            args: [{ providedIn: 'root' }]
        }], ctorParameters: () => [{ type: i0.RendererFactory2 }, { type: Document, decorators: [{
                    type: Inject,
                    args: [DOCUMENT]
                }] }] });
class BrowserAnimationFactory extends AnimationFactory {
    constructor(_id, _renderer) {
        super();
        this._id = _id;
        this._renderer = _renderer;
    }
    create(element, options) {
        return new RendererAnimationPlayer(this._id, element, options || {}, this._renderer);
    }
}
class RendererAnimationPlayer {
    constructor(id, element, options, _renderer) {
        this.id = id;
        this.element = element;
        this._renderer = _renderer;
        this.parentPlayer = null;
        this._started = false;
        this.totalTime = 0;
        this._command('create', options);
    }
    _listen(eventName, callback) {
        return this._renderer.listen(this.element, `@@${this.id}:${eventName}`, callback);
    }
    _command(command, ...args) {
        issueAnimationCommand(this._renderer, this.element, this.id, command, args);
    }
    onDone(fn) {
        this._listen('done', fn);
    }
    onStart(fn) {
        this._listen('start', fn);
    }
    onDestroy(fn) {
        this._listen('destroy', fn);
    }
    init() {
        this._command('init');
    }
    hasStarted() {
        return this._started;
    }
    play() {
        this._command('play');
        this._started = true;
    }
    pause() {
        this._command('pause');
    }
    restart() {
        this._command('restart');
    }
    finish() {
        this._command('finish');
    }
    destroy() {
        this._command('destroy');
    }
    reset() {
        this._command('reset');
        this._started = false;
    }
    setPosition(p) {
        this._command('setPosition', p);
    }
    getPosition() {
        return unwrapAnimationRenderer(this._renderer)?.engine?.players[this.id]?.getPosition() ?? 0;
    }
}
function issueAnimationCommand(renderer, element, id, command, args) {
    renderer.setProperty(element, `@@${id}:${command}`, args);
}
/**
 * The following 2 methods cannot reference their correct types (AnimationRenderer &
 * DynamicDelegationRenderer) since this would introduce a import cycle.
 */
function unwrapAnimationRenderer(renderer) {
    const type = renderer.ɵtype;
    if (type === 0 /* AnimationRendererType.Regular */) {
        return renderer;
    }
    else if (type === 1 /* AnimationRendererType.Delegated */) {
        return renderer.animationRenderer;
    }
    return null;
}
function isAnimationRenderer(renderer) {
    const type = renderer.ɵtype;
    return type === 0 /* AnimationRendererType.Regular */ || type === 1 /* AnimationRendererType.Delegated */;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"animation_builder.js","sourceRoot":"","sources":["../../../../../../packages/animations/src/animation_builder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport {DOCUMENT} from '@angular/common';\nimport {\n  ANIMATION_MODULE_TYPE,\n  Inject,\n  inject,\n  Injectable,\n  Renderer2,\n  RendererFactory2,\n  RendererType2,\n  ViewEncapsulation,\n  ɵAnimationRendererType as AnimationRendererType,\n  ɵRuntimeError as RuntimeError,\n} from '@angular/core';\n\nimport {AnimationMetadata, AnimationOptions, sequence} from './animation_metadata';\nimport {RuntimeErrorCode} from './errors';\nimport {AnimationPlayer} from './players/animation_player';\n\n/**\n * An injectable service that produces an animation sequence programmatically within an\n * Angular component or directive.\n * Provided by the `BrowserAnimationsModule` or `NoopAnimationsModule`.\n *\n * @usageNotes\n *\n * To use this service, add it to your component or directive as a dependency.\n * The service is instantiated along with your component.\n *\n * Apps do not typically need to create their own animation players, but if you\n * do need to, follow these steps:\n *\n * 1. Use the <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code> method\n * to create a programmatic animation. The method returns an `AnimationFactory` instance.\n *\n * 2. Use the factory object to create an `AnimationPlayer` and attach it to a DOM element.\n *\n * 3. Use the player object to control the animation programmatically.\n *\n * For example:\n *\n * ```ts\n * // import the service from BrowserAnimationsModule\n * import {AnimationBuilder} from '@angular/animations';\n * // require the service as a dependency\n * class MyCmp {\n *   constructor(private _builder: AnimationBuilder) {}\n *\n *   makeAnimation(element: any) {\n *     // first define a reusable animation\n *     const myAnimation = this._builder.build([\n *       style({ width: 0 }),\n *       animate(1000, style({ width: '100px' }))\n *     ]);\n *\n *     // use the returned factory object to create a player\n *     const player = myAnimation.create(element);\n *\n *     player.play();\n *   }\n * }\n * ```\n *\n * @publicApi\n */\n@Injectable({providedIn: 'root', useFactory: () => inject(BrowserAnimationBuilder)})\nexport abstract class AnimationBuilder {\n  /**\n   * Builds a factory for producing a defined animation.\n   * @param animation A reusable animation definition.\n   * @returns A factory object that can create a player for the defined animation.\n   * @see {@link animate}\n   */\n  abstract build(animation: AnimationMetadata | AnimationMetadata[]): AnimationFactory;\n}\n\n/**\n * A factory object returned from the\n * <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code>\n * method.\n *\n * @publicApi\n */\nexport abstract class AnimationFactory {\n  /**\n   * Creates an `AnimationPlayer` instance for the reusable animation defined by\n   * the <code>[AnimationBuilder.build](api/animations/AnimationBuilder#build)()</code>\n   * method that created this factory and attaches the new player a DOM element.\n   *\n   * @param element The DOM element to which to attach the player.\n   * @param options A set of options that can include a time delay and\n   * additional developer-defined parameters.\n   */\n  abstract create(element: any, options?: AnimationOptions): AnimationPlayer;\n}\n\n@Injectable({providedIn: 'root'})\nexport class BrowserAnimationBuilder extends AnimationBuilder {\n  private animationModuleType = inject(ANIMATION_MODULE_TYPE, {optional: true});\n  private _nextAnimationId = 0;\n  private _renderer: Renderer2;\n\n  constructor(rootRenderer: RendererFactory2, @Inject(DOCUMENT) doc: Document) {\n    super();\n    const typeData: RendererType2 = {\n      id: '0',\n      encapsulation: ViewEncapsulation.None,\n      styles: [],\n      data: {animation: []},\n    };\n    this._renderer = rootRenderer.createRenderer(doc.body, typeData);\n\n    if (this.animationModuleType === null && !isAnimationRenderer(this._renderer)) {\n      // We only support AnimationRenderer & DynamicDelegationRenderer for this AnimationBuilder\n\n      throw new RuntimeError(\n        RuntimeErrorCode.BROWSER_ANIMATION_BUILDER_INJECTED_WITHOUT_ANIMATIONS,\n        (typeof ngDevMode === 'undefined' || ngDevMode) &&\n          'Angular detected that the `AnimationBuilder` was injected, but animation support was not enabled. ' +\n            'Please make sure that you enable animations in your application by calling `provideAnimations()` or `provideAnimationsAsync()` function.',\n      );\n    }\n  }\n\n  override build(animation: AnimationMetadata | AnimationMetadata[]): AnimationFactory {\n    const id = this._nextAnimationId;\n    this._nextAnimationId++;\n    const entry = Array.isArray(animation) ? sequence(animation) : animation;\n    issueAnimationCommand(this._renderer, null, id, 'register', [entry]);\n    return new BrowserAnimationFactory(id, this._renderer);\n  }\n}\n\nclass BrowserAnimationFactory extends AnimationFactory {\n  constructor(\n    private _id: number,\n    private _renderer: Renderer2,\n  ) {\n    super();\n  }\n\n  override create(element: any, options?: AnimationOptions): AnimationPlayer {\n    return new RendererAnimationPlayer(this._id, element, options || {}, this._renderer);\n  }\n}\n\nclass RendererAnimationPlayer implements AnimationPlayer {\n  public parentPlayer: AnimationPlayer | null = null;\n  private _started = false;\n\n  constructor(\n    public id: number,\n    public element: any,\n    options: AnimationOptions,\n    private _renderer: Renderer2,\n  ) {\n    this._command('create', options);\n  }\n\n  private _listen(eventName: string, callback: (event: any) => any): () => void {\n    return this._renderer.listen(this.element, `@@${this.id}:${eventName}`, callback);\n  }\n\n  private _command(command: string, ...args: any[]): void {\n    issueAnimationCommand(this._renderer, this.element, this.id, command, args);\n  }\n\n  onDone(fn: () => void): void {\n    this._listen('done', fn);\n  }\n\n  onStart(fn: () => void): void {\n    this._listen('start', fn);\n  }\n\n  onDestroy(fn: () => void): void {\n    this._listen('destroy', fn);\n  }\n\n  init(): void {\n    this._command('init');\n  }\n\n  hasStarted(): boolean {\n    return this._started;\n  }\n\n  play(): void {\n    this._command('play');\n    this._started = true;\n  }\n\n  pause(): void {\n    this._command('pause');\n  }\n\n  restart(): void {\n    this._command('restart');\n  }\n\n  finish(): void {\n    this._command('finish');\n  }\n\n  destroy(): void {\n    this._command('destroy');\n  }\n\n  reset(): void {\n    this._command('reset');\n    this._started = false;\n  }\n\n  setPosition(p: number): void {\n    this._command('setPosition', p);\n  }\n\n  getPosition(): number {\n    return unwrapAnimationRenderer(this._renderer)?.engine?.players[this.id]?.getPosition() ?? 0;\n  }\n\n  public totalTime = 0;\n}\n\nfunction issueAnimationCommand(\n  renderer: Renderer2,\n  element: any,\n  id: number,\n  command: string,\n  args: any[],\n): void {\n  renderer.setProperty(element, `@@${id}:${command}`, args);\n}\n\n/**\n * The following 2 methods cannot reference their correct types (AnimationRenderer &\n * DynamicDelegationRenderer) since this would introduce a import cycle.\n */\n\nfunction unwrapAnimationRenderer(\n  renderer: Renderer2,\n): {engine: {players: AnimationPlayer[]}} | null {\n  const type = (renderer as unknown as {ɵtype: AnimationRendererType}).ɵtype;\n  if (type === AnimationRendererType.Regular) {\n    return renderer as any;\n  } else if (type === AnimationRendererType.Delegated) {\n    return (renderer as any).animationRenderer;\n  }\n\n  return null;\n}\n\nfunction isAnimationRenderer(renderer: Renderer2): boolean {\n  const type = (renderer as unknown as {ɵtype: AnimationRendererType}).ɵtype;\n  return type === AnimationRendererType.Regular || type === AnimationRendererType.Delegated;\n}\n"]}