import {
  Component,
  EventEmitter,
  HostBinding,
  Input,
  Output,
} from "@angular/core";
import {
  animate,
  state,
  style,
  transition,
  trigger,
} from "@angular/animations";

@Component({
  selector: "my-popup",
  template: `
    Popup: {{ message }}
    ✖
  `,
  animations: [
    trigger("state", [
      state(
        "opened",
        style({ transform: "translateY(0%)" })
      ),
      state(
        "void, closed",
        style({ transform: "translateY(100%)", opacity: 0 })
      ),
      transition("* => *", animate("100ms ease-in")),
    ]),
  ],
  styles: [
    `
      :host {
        position: absolute;
        bottom: 0;
        left: 0;
        right: 0;
        background: #009cff;
        height: 48px;
        padding: 16px;
        display: flex;
        justify-content: space-between;
        align-items: center;
        border-top: 1px solid black;
        font-size: 24px;
      }

      button {
        border-radius: 50%;
      }
    `,
  ],
})
export class PopupComponent {
  @HostBinding("@state")
  state: "opened" | "closed" = "closed";

  @Input()
  get message(): string {
    return this._message;
  }
  set message(message: string) {
    this._message = message;
    this.state = "opened";
  }
  private _message = "";

  @Output()
  closed = new EventEmitter();
}

export class ItemOutputComponent {
  @Output() newItemEvent = new EventEmitter();

  addNewItem(value: string) {
    this.newItemEvent.emit(value);
  }
}

export class SizerComponent {
  @Input() size!: number | string;
  @Output() sizeChange = new EventEmitter();

  dec() {
    this.resize(-1);
  }
  inc() {
    this.resize(+1);
  }

  resize(delta: number) {
    this.size = Math.min(
      40,
      Math.max(8, +this.size + delta)
    );
    this.sizeChange.emit(this.size);
  }
}

@Output() newItemEvent = new EventEmitter();

@Component({
  selector: "app-zippy",
  template: `
    

      
Toggle
      

        
      
    
  `,
})
export class ZippyComponent {
  visible = true;
  @Output() open = new EventEmitter();
  @Output() close = new EventEmitter();

  toggle() {
    this.visible = !this.visible;
    if (this.visible) {
      this.open.emit(null);
    } else {
      this.close.emit(null);
    }
  }
}

const template = "
{{hero.name}}
";

@Component({
  selector: "app-hero",
  template: template,
})
export class HeroComponent {
  @Input() hero: Hero;
}

@Input() set appUnless(condition: boolean) {
  if (!condition && !this.hasView) {
    this.viewContainer.createEmbeddedView(this.templateRef);
    this.hasView = true;
  } else if (condition && this.hasView) {
    this.viewContainer.clear();
    this.hasView = false;
  }
}

import { Component, Input } from "@angular/core";

import { AdComponent } from "./ad.component";

@Component({
  template: `
    

      
{{ data.headline }}

      {{ data.body }}
    
  `,
})
export class HeroJobAdComponent implements AdComponent {
  @Input() data: any;
}

export class StoutItemComponent {
  @Input() item!: Item;
}

const template = "
{{hero.name}}
";

@Component({
  selector: "app-hero",
  template: template + "
{{hero.title}}
",
})
export class HeroComponent {
  @Input() hero: Hero;
}

import { Component, Input } from "@angular/core"; // First, import Input
export class ItemDetailComponent {
  @Input() item = ""; // decorate the property with @Input()
}

@Directive({
  selector: "[appForbiddenName]",
  providers: [
    {
      provide: NG_VALIDATORS,
      useExisting: ForbiddenValidatorDirective,
      multi: true,
    },
  ],
})
export class ForbiddenValidatorDirective
  implements Validator
{
  @Input("appForbiddenName") forbiddenName = "";

  validate(
    control: AbstractControl
  ): ValidationErrors | null {
    return this.forbiddenName
      ? forbiddenNameValidator(
          new RegExp(this.forbiddenName, "i")
        )(control)
      : null;
  }
}

export type Loaded = { type: "loaded"; data: T };
export type Loading = { type: "loading" };
export type LoadingState = Loaded | Loading;
export class IfLoadedDirective {
  @Input("ifLoaded") set state(state: LoadingState) {}
  static ngTemplateGuard_state(
    dir: IfLoadedDirective,
    expr: LoadingState
  ): expr is Loaded {
    return true;
  }
}

export interface Person {
  name: string;
}

@Component({
  template: `
{{ state.data }}
`,
})
export class AppComponent {
  state: LoadingState;
}

import {
  Directive,
  ElementRef,
  Input,
  OnChanges,
} from "@angular/core";

@Directive({ selector: "[highlight]" })
/**
 * Set backgroundColor for the attached element to highlight color
 * and set the element's customProperty to true
 */
export class HighlightDirective implements OnChanges {
  defaultColor = "rgb(211, 211, 211)"; // lightgray

  @Input("highlight") bgColor = "";

  constructor(private el: ElementRef) {
    el.nativeElement.style.customProperty = true;
  }

  ngOnChanges() {
    this.el.nativeElement.style.backgroundColor =
      this.bgColor || this.defaultColor;
  }
}

import {
  Directive,
  ElementRef,
  HostListener,
  Input,
} from "@angular/core";

@Directive({
  selector: "[appHighlight]",
})
export class HighlightDirective {
  @Input("appHighlight") highlightColor = "";

  private el: HTMLElement;

  constructor(el: ElementRef) {
    this.el = el.nativeElement;
  }

  @HostListener("mouseenter") onMouseEnter() {
    this.highlight(this.highlightColor || "cyan");
  }

  @HostListener("mouseleave") onMouseLeave() {
    this.highlight("");
  }

  private highlight(color: string) {
    this.el.style.backgroundColor = color;
  }
}

@Input() appHighlight = '';

import {
  Component,
  EventEmitter,
  HostBinding,
  Input,
  Output,
} from "@angular/core";
import {
  animate,
  state,
  style,
  transition,
  trigger,
} from "@angular/animations";

@Component({
  selector: "my-popup",
  template: `
    Popup: {{ message }}
    ✖
  `,
  animations: [
    trigger("state", [
      state(
        "opened",
        style({ transform: "translateY(0%)" })
      ),
      state(
        "void, closed",
        style({ transform: "translateY(100%)", opacity: 0 })
      ),
      transition("* => *", animate("100ms ease-in")),
    ]),
  ],
  styles: [
    `
      :host {
        position: absolute;
        bottom: 0;
        left: 0;
        right: 0;
        background: #009cff;
        height: 48px;
        padding: 16px;
        display: flex;
        justify-content: space-between;
        align-items: center;
        border-top: 1px solid black;
        font-size: 24px;
      }

      button {
        border-radius: 50%;
      }
    `,
  ],
})
export class PopupComponent {
  @HostBinding("@state")
  state: "opened" | "closed" = "closed";

  @Input()
  get message(): string {
    return this._message;
  }
  set message(message: string) {
    this._message = message;
    this.state = "opened";
  }
  private _message = "";

  @Output()
  closed = new EventEmitter();
}

import { Component, OnInit, Input } from "@angular/core";
import { Hero } from "../hero";

@Component({
  selector: "app-hero-detail",
  templateUrl: "./hero-detail.component.html",
  styleUrls: ["./hero-detail.component.css"],
})
export class HeroDetailComponent implements OnInit {
  @Input() hero?: Hero;

  constructor() {}

  ngOnInit() {}
}

export class SizerComponent {
  @Input() size!: number | string;
  @Output() sizeChange = new EventEmitter();

  dec() {
    this.resize(-1);
  }
  inc() {
    this.resize(+1);
  }

  resize(delta: number) {
    this.size = Math.min(
      40,
      Math.max(8, +this.size + delta)
    );
    this.sizeChange.emit(this.size);
  }
}

@Component({
  selector: "app-hero-bio",
  template: ` 
{{ hero.name }}
    
    `,
  providers: [HeroCacheService],
})
export class HeroBioComponent implements OnInit {
  @Input() heroId = 0;

  constructor(private heroCache: HeroCacheService) {}

  ngOnInit() {
    this.heroCache.fetchCachedHero(this.heroId);
  }

  get hero() {
    return this.heroCache.hero;
  }
}

@Component({
  selector: 'app-typical',
  template: '
A typical component for {{data.name}}
'
})
export class TypicalComponent {
  @Input() data: TypicalData;
  constructor(private someService: SomeService) { ... }
}

@Input() hero?: Hero;

@Component({
  selector: "app-hero",
  template: "
{{hero.name}}
",
})
export class HeroComponent {
  @Input() hero: Hero;
}

export class AdBannerComponent
  implements OnInit, OnDestroy
{
  @Input() ads: AdItem[] = [];
  currentAdIndex = -1;
  @ViewChild(AdDirective, { static: true })
  adHost!: AdDirective;
  interval: number | undefined;

  constructor(
    private componentFactoryResolver: ComponentFactoryResolver
  ) {}

  ngOnInit() {
    this.loadComponent();
    this.getAds();
  }

  ngOnDestroy() {
    clearInterval(this.interval);
  }

  loadComponent() {
    this.currentAdIndex =
      (this.currentAdIndex + 1) % this.ads.length;
    const adItem = this.ads[this.currentAdIndex];

    const componentFactory =
      this.componentFactoryResolver.resolveComponentFactory(
        adItem.component
      );

    const viewContainerRef = this.adHost.viewContainerRef;
    viewContainerRef.clear();

    const componentRef =
      viewContainerRef.createComponent(
        componentFactory
      );
    componentRef.instance.data = adItem.data;
  }

  getAds() {
    this.interval = setInterval(() => {
      this.loadComponent();
    }, 3000);
  }
}

@Input() defaultColor = '';

@Component(...)
class MyDialog {
  @Input() content: string;
}

import {
  Directive,
  Input,
  TemplateRef,
  ViewContainerRef,
} from "@angular/core";

/**
 * Add the template content to the DOM unless the condition is true.
 */
@Directive({ selector: "[appUnless]" })
export class UnlessDirective {
  private hasView = false;

  constructor(
    private templateRef: TemplateRef,
    private viewContainer: ViewContainerRef
  ) {}

  @Input() set appUnless(condition: boolean) {
    if (!condition && !this.hasView) {
      this.viewContainer.createEmbeddedView(
        this.templateRef
      );
      this.hasView = true;
    } else if (condition && this.hasView) {
      this.viewContainer.clear();
      this.hasView = false;
    }
  }
}

const handler = jest.fn();

const {
  container: { firstChild: input },
} = render();

fireEvent.input(input, { target: { value: "a" } });

expect(handler).toHaveBeenCalledTimes(1);

const ref = createRef();
const spy = jest.fn();

render(
  h(elementType, {
    onDblClick: spy,
    ref,
  })
);

fireEvent["onDblClick"](ref.current);

expect(spy).toHaveBeenCalledTimes(1);

const { getByLabelText, queryAllByTestId } =
  render(Component);

// With options.
const { results } = render(YourComponent, {
  target: MyTarget,
  props: { myProp: "value" },
});

// Props only.
const { results } = render(YourComponent, {
  myProp: "value",
});

const cb = jest.fn();


function Counter() {
  useEffect(cb);


  const [count, setCount] = useState(0);


  return  setCount(count + 1)}>{count};
}


const { container: { firstChild: buttonNode }, } = render();


// Clear the first call to useEffect that the initial render triggers.
cb.mockClear();


// Fire event Option 1.
fireEvent.click(buttonNode);


// Fire event Option 2.
fireEvent(
buttonNode,
new Event('MouseEvent', {
  bubbles: true,
  cancelable: true,
  button: 0,
});


expect(buttonNode).toHaveTextContent('1');
expect(cb).toHaveBeenCalledTimes(1);

const table = document.createElement("table");

const { container } = render(TableBody, {
  props,
  container: document.body.appendChild(table),
});

const { getByDataCy } = render();

expect(getByDataCy("my-component")).toHaveTextContent(
  "Hello"
);

test("has correct welcome text", () => {
  render();
  expect(screen.getByRole("heading")).toHaveTextContent(
    "Welcome, John Doe"
  );
});

render();

test("handles click correctly", () => {
  render();

  userEvent.click(screen.getByText("Check"));
  expect(screen.getByLabelText("Check")).toBeChecked();
});

// Example, a function to traverse table contents
import * as tableQueries from "my-table-query-library";
import { queries } from "@testing-library/react";

const { getByRowColumn, getByText } = render(, {
  queries: { ...queries, ...tableQueries },
});

test("has correct input value", () => {
  render();
  expect(screen.getByRole("form")).toHaveFormValues({
    firstName: "John",
    lastName: "Doe",
  });
});

const table = document.createElement("table");

const { container } = render(, {
  container: document.body.appendChild(table),
});

// @testing-library/react
const { container } = render();
const foo = container.querySelector('[data-foo="bar"]');

const { getByLabelText, queryAllByTestId } = render(
  
);

test("loads items eventually", async () => {
  // Click button
  fireEvent.click(getByText(node, "Load"));

  // Wait for page to update with query text
  const items = await findByText(node, /Item #[0-9]: /);
  expect(items).toHaveLength(10);
});

test("movie title appears", async () => {
  // element is initially not present...

  // wait for appearance inside an assertion
  await waitFor(() => {
    expect(getByText("the lion king")).toBeInTheDocument();
  });
});

const puppeteer = require("puppeteer");
const {
  getDocument,
  queries,
  waitFor,
} = require("pptr-testing-library");

const { getByTestId, getByLabelText } = queries;

const browser = await puppeteer.launch();
const page = await browser.newPage();

// Grab ElementHandle for document
const $document = await getDocument(page);
// Your favorite query methods are available
const $form = await getByTestId($document, "my-form");
// returned elements are Puppeteer ElementHandles too!
const $email = await getByLabelText($form, "Email");
// interact with puppeteer like usual
await $email.type("pptr@example.com");
// waiting works too!
await waitFor(() => getByText("Loading..."));

await fireEvent.click(getByText("Click me"));

test("loads items eventually", async () => {
  // Click button
  fireEvent.click(getByText(node, "Load"));

  // Wait for page to update with query text
  const items = await findByText(node, /Item #[0-9]: /);
  expect(items).toHaveLength(10);
});

test("movie title appears", async () => {
  // element is initially not present...
  // wait for appearance and return the element
  const movie = await findByText("the lion king");
});