@storybook/angular 9.1.0-alpha.5 → 9.1.0-alpha.7

package/dist/client/angular-beta/utils/NgComponentAnalyzer.test.mjs

@@ -1,386 +0,0 @@
-// @vitest-environment happy-dom
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { Component, ComponentFactoryResolver, Directive, EventEmitter, HostBinding, Injectable, Input, Output, Pipe, input, output, } from '@angular/core';
-import { TestBed } from '@angular/core/testing';
-import { BrowserDynamicTestingModule } from '@angular/platform-browser-dynamic/testing';
-import { describe, expect, it } from 'vitest';
-import { getComponentInputsOutputs, isComponent, isDeclarable, getComponentDecoratorMetadata, isStandaloneComponent, } from './NgComponentAnalyzer';
-describe('getComponentInputsOutputs', () => {
-    it('should return empty if no I/O found', () => {
-        let FooComponent = class FooComponent {
-        };
-        FooComponent = __decorate([
-            Component({
-                standalone: false,
-            })
-        ], FooComponent);
-        expect(getComponentInputsOutputs(FooComponent)).toEqual({
-            inputs: [],
-            outputs: [],
-        });
-        class BarComponent {
-        }
-        expect(getComponentInputsOutputs(BarComponent)).toEqual({
-            inputs: [],
-            outputs: [],
-        });
-    });
-    it('should return I/O', () => {
-        let FooComponent = class FooComponent {
-            constructor() {
-                this.signalInput = input();
-                this.signalInputAliased = input('signalInputAliased', {
-                    alias: 'signalInputAliasedAlias',
-                });
-                this.output = new EventEmitter();
-                this.outputWithBindingPropertyName = new EventEmitter();
-                this.signalOutput = output();
-            }
-        };
-        __decorate([
-            Input(),
-            __metadata("design:type", String)
-        ], FooComponent.prototype, "input", void 0);
-        __decorate([
-            Input('inputPropertyName'),
-            __metadata("design:type", String)
-        ], FooComponent.prototype, "inputWithBindingPropertyName", void 0);
-        __decorate([
-            Output(),
-            __metadata("design:type", Object)
-        ], FooComponent.prototype, "output", void 0);
-        __decorate([
-            Output('outputPropertyName'),
-            __metadata("design:type", Object)
-        ], FooComponent.prototype, "outputWithBindingPropertyName", void 0);
-        FooComponent = __decorate([
-            Component({
-                template: '',
-                inputs: ['inputInComponentMetadata'],
-                outputs: ['outputInComponentMetadata'],
-                standalone: false,
-            })
-        ], FooComponent);
-        const fooComponentFactory = resolveComponentFactory(FooComponent);
-        const { inputs, outputs } = getComponentInputsOutputs(FooComponent);
-        expect({ inputs, outputs }).toEqual({
-            inputs: [
-                { propName: 'inputInComponentMetadata', templateName: 'inputInComponentMetadata' },
-                { propName: 'input', templateName: 'input' },
-                { propName: 'inputWithBindingPropertyName', templateName: 'inputPropertyName' },
-            ],
-            outputs: [
-                { propName: 'outputInComponentMetadata', templateName: 'outputInComponentMetadata' },
-                { propName: 'output', templateName: 'output' },
-                { propName: 'outputWithBindingPropertyName', templateName: 'outputPropertyName' },
-            ],
-        });
-        expect(sortByPropName(inputs)).toEqual(sortByPropName(fooComponentFactory.inputs.map(({ isSignal, ...rest }) => rest)));
-        expect(sortByPropName(outputs)).toEqual(sortByPropName(fooComponentFactory.outputs));
-    });
-    it("should return I/O when some of component metadata has the same name as one of component's properties", () => {
-        let FooComponent = class FooComponent {
-            constructor() {
-                this.output = new EventEmitter();
-                this.outputWithBindingPropertyName = new EventEmitter();
-            }
-        };
-        __decorate([
-            Input(),
-            __metadata("design:type", String)
-        ], FooComponent.prototype, "input", void 0);
-        __decorate([
-            Input('inputPropertyName'),
-            __metadata("design:type", String)
-        ], FooComponent.prototype, "inputWithBindingPropertyName", void 0);
-        __decorate([
-            Output(),
-            __metadata("design:type", Object)
-        ], FooComponent.prototype, "output", void 0);
-        __decorate([
-            Output('outputPropertyName'),
-            __metadata("design:type", Object)
-        ], FooComponent.prototype, "outputWithBindingPropertyName", void 0);
-        FooComponent = __decorate([
-            Component({
-                template: '',
-                inputs: ['input', 'inputWithBindingPropertyName'],
-                outputs: ['outputWithBindingPropertyName'],
-                standalone: false,
-            })
-        ], FooComponent);
-        const fooComponentFactory = resolveComponentFactory(FooComponent);
-        const { inputs, outputs } = getComponentInputsOutputs(FooComponent);
-        expect(sortByPropName(inputs)).toEqual(sortByPropName(fooComponentFactory.inputs.map(({ isSignal, ...rest }) => rest)));
-        expect(sortByPropName(outputs)).toEqual(sortByPropName(fooComponentFactory.outputs));
-    });
-    it('should return I/O in the presence of multiple decorators', () => {
-        let FooComponent = class FooComponent {
-        };
-        __decorate([
-            Input(),
-            HostBinding('class.preceeding-first'),
-            __metadata("design:type", String)
-        ], FooComponent.prototype, "inputPreceedingHostBinding", void 0);
-        __decorate([
-            HostBinding('class.following-binding'),
-            Input(),
-            __metadata("design:type", String)
-        ], FooComponent.prototype, "inputFollowingHostBinding", void 0);
-        FooComponent = __decorate([
-            Component({
-                template: '',
-                standalone: false,
-            })
-        ], FooComponent);
-        const fooComponentFactory = resolveComponentFactory(FooComponent);
-        const { inputs, outputs } = getComponentInputsOutputs(FooComponent);
-        expect({ inputs, outputs }).toEqual({
-            inputs: [
-                { propName: 'inputPreceedingHostBinding', templateName: 'inputPreceedingHostBinding' },
-                { propName: 'inputFollowingHostBinding', templateName: 'inputFollowingHostBinding' },
-            ],
-            outputs: [],
-        });
-        expect(sortByPropName(inputs)).toEqual(sortByPropName(fooComponentFactory.inputs.map(({ isSignal, ...rest }) => rest)));
-        expect(sortByPropName(outputs)).toEqual(sortByPropName(fooComponentFactory.outputs));
-    });
-    it('should return I/O with extending classes', () => {
-        let BarComponent = class BarComponent {
-        };
-        __decorate([
-            Input(),
-            __metadata("design:type", String)
-        ], BarComponent.prototype, "a", void 0);
-        __decorate([
-            Input(),
-            __metadata("design:type", String)
-        ], BarComponent.prototype, "b", void 0);
-        BarComponent = __decorate([
-            Component({
-                template: '',
-                standalone: false,
-            })
-        ], BarComponent);
-        let FooComponent = class FooComponent extends BarComponent {
-        };
-        __decorate([
-            Input(),
-            __metadata("design:type", String)
-        ], FooComponent.prototype, "b", void 0);
-        __decorate([
-            Input(),
-            __metadata("design:type", String)
-        ], FooComponent.prototype, "c", void 0);
-        FooComponent = __decorate([
-            Component({
-                template: '',
-                standalone: false,
-            })
-        ], FooComponent);
-        const fooComponentFactory = resolveComponentFactory(FooComponent);
-        const { inputs, outputs } = getComponentInputsOutputs(FooComponent);
-        expect({ inputs, outputs }).toEqual({
-            inputs: [
-                { propName: 'a', templateName: 'a' },
-                { propName: 'b', templateName: 'b' },
-                { propName: 'c', templateName: 'c' },
-            ],
-            outputs: [],
-        });
-        expect(sortByPropName(inputs)).toEqual(sortByPropName(fooComponentFactory.inputs.map(({ isSignal, ...rest }) => rest)));
-        expect(sortByPropName(outputs)).toEqual(sortByPropName(fooComponentFactory.outputs));
-    });
-});
-describe('isDeclarable', () => {
-    it('should return true with a Component', () => {
-        let FooComponent = class FooComponent {
-        };
-        FooComponent = __decorate([
-            Component({})
-        ], FooComponent);
-        expect(isDeclarable(FooComponent)).toEqual(true);
-    });
-    it('should return true with a Directive', () => {
-        let FooDirective = class FooDirective {
-        };
-        FooDirective = __decorate([
-            Directive({})
-        ], FooDirective);
-        expect(isDeclarable(FooDirective)).toEqual(true);
-    });
-    it('should return true with a Pipe', () => {
-        let FooPipe = class FooPipe {
-        };
-        FooPipe = __decorate([
-            Pipe({ name: 'pipe' })
-        ], FooPipe);
-        expect(isDeclarable(FooPipe)).toEqual(true);
-    });
-    it('should return false with simple class', () => {
-        class FooPipe {
-        }
-        expect(isDeclarable(FooPipe)).toEqual(false);
-    });
-    it('should return false with Injectable', () => {
-        let FooInjectable = class FooInjectable {
-        };
-        FooInjectable = __decorate([
-            Injectable()
-        ], FooInjectable);
-        expect(isDeclarable(FooInjectable)).toEqual(false);
-    });
-});
-describe('isComponent', () => {
-    it('should return true with a Component', () => {
-        let FooComponent = class FooComponent {
-        };
-        FooComponent = __decorate([
-            Component({})
-        ], FooComponent);
-        expect(isComponent(FooComponent)).toEqual(true);
-    });
-    it('should return false with simple class', () => {
-        class FooPipe {
-        }
-        expect(isComponent(FooPipe)).toEqual(false);
-    });
-    it('should return false with Directive', () => {
-        let FooDirective = class FooDirective {
-        };
-        FooDirective = __decorate([
-            Directive()
-        ], FooDirective);
-        expect(isComponent(FooDirective)).toEqual(false);
-    });
-});
-describe('isStandaloneComponent', () => {
-    it('should return true with a Component with "standalone: true"', () => {
-        let FooComponent = class FooComponent {
-        };
-        FooComponent = __decorate([
-            Component({ standalone: true })
-        ], FooComponent);
-        expect(isStandaloneComponent(FooComponent)).toEqual(true);
-    });
-    it('should return false with a Component with "standalone: false"', () => {
-        let FooComponent = class FooComponent {
-        };
-        FooComponent = __decorate([
-            Component({ standalone: false })
-        ], FooComponent);
-        expect(isStandaloneComponent(FooComponent)).toEqual(false);
-    });
-    it('should return false with a Component without the "standalone" property', () => {
-        let FooComponent = class FooComponent {
-        };
-        FooComponent = __decorate([
-            Component({})
-        ], FooComponent);
-        expect(isStandaloneComponent(FooComponent)).toEqual(false);
-    });
-    it('should return false with simple class', () => {
-        class FooPipe {
-        }
-        expect(isStandaloneComponent(FooPipe)).toEqual(false);
-    });
-    it('should return true with a Directive with "standalone: true"', () => {
-        let FooDirective = class FooDirective {
-        };
-        FooDirective = __decorate([
-            Directive({ standalone: true })
-        ], FooDirective);
-        expect(isStandaloneComponent(FooDirective)).toEqual(true);
-    });
-    it('should return false with a Directive with "standalone: false"', () => {
-        let FooDirective = class FooDirective {
-        };
-        FooDirective = __decorate([
-            Directive({ standalone: false })
-        ], FooDirective);
-        expect(isStandaloneComponent(FooDirective)).toEqual(false);
-    });
-    it('should return false with Directive without the "standalone" property', () => {
-        let FooDirective = class FooDirective {
-        };
-        FooDirective = __decorate([
-            Directive()
-        ], FooDirective);
-        expect(isStandaloneComponent(FooDirective)).toEqual(false);
-    });
-    it('should return true with a Pipe with "standalone: true"', () => {
-        let FooPipe = class FooPipe {
-        };
-        FooPipe = __decorate([
-            Pipe({ name: 'FooPipe', standalone: true })
-        ], FooPipe);
-        expect(isStandaloneComponent(FooPipe)).toEqual(true);
-    });
-    it('should return false with a Pipe with "standalone: false"', () => {
-        let FooPipe = class FooPipe {
-        };
-        FooPipe = __decorate([
-            Pipe({ name: 'FooPipe', standalone: false })
-        ], FooPipe);
-        expect(isStandaloneComponent(FooPipe)).toEqual(false);
-    });
-    it('should return false with Pipe without the "standalone" property', () => {
-        let FooPipe = class FooPipe {
-        };
-        FooPipe = __decorate([
-            Pipe({
-                name: 'fooPipe',
-            })
-        ], FooPipe);
-        expect(isStandaloneComponent(FooPipe)).toEqual(false);
-    });
-});
-describe('getComponentDecoratorMetadata', () => {
-    it('should return Component with a Component', () => {
-        let FooComponent = class FooComponent {
-        };
-        FooComponent = __decorate([
-            Component({ selector: 'foo' })
-        ], FooComponent);
-        expect(getComponentDecoratorMetadata(FooComponent)).toBeInstanceOf(Component);
-        expect(getComponentDecoratorMetadata(FooComponent)).toEqual({
-            changeDetection: 1,
-            selector: 'foo',
-        });
-    });
-    it('should return Component with extending classes', () => {
-        let BarComponent = class BarComponent {
-        };
-        BarComponent = __decorate([
-            Component({ selector: 'bar' })
-        ], BarComponent);
-        let FooComponent = class FooComponent extends BarComponent {
-        };
-        FooComponent = __decorate([
-            Component({ selector: 'foo' })
-        ], FooComponent);
-        expect(getComponentDecoratorMetadata(FooComponent)).toBeInstanceOf(Component);
-        expect(getComponentDecoratorMetadata(FooComponent)).toEqual({
-            changeDetection: 1,
-            selector: 'foo',
-        });
-    });
-});
-function sortByPropName(array) {
-    return array.sort((a, b) => a.propName.localeCompare(b.propName));
-}
-function resolveComponentFactory(component) {
-    TestBed.configureTestingModule({
-        declarations: [component],
-    }).overrideModule(BrowserDynamicTestingModule, {});
-    const componentFactoryResolver = TestBed.inject(ComponentFactoryResolver);
-    return componentFactoryResolver.resolveComponentFactory(component);
-}

package/dist/client/angular-beta/utils/NgModulesAnalyzer.d.ts

@@ -1,6 +0,0 @@
-/**
- * Avoid component redeclaration
- *
- * Checks recursively if the component has already been declared in all import Module
- */
-export declare const isComponentAlreadyDeclared: (componentToFind: any, moduleDeclarations: any[], moduleImports: any[]) => boolean;

package/dist/client/angular-beta/utils/NgModulesAnalyzer.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isComponentAlreadyDeclared = void 0;
-const core_1 = require("@angular/core");
-const reflectionCapabilities = new core_1.ɵReflectionCapabilities();
-/**
- * Avoid component redeclaration
- *
- * Checks recursively if the component has already been declared in all import Module
- */
-const isComponentAlreadyDeclared = (componentToFind, moduleDeclarations, moduleImports) => {
-    if (moduleDeclarations &&
-        moduleDeclarations.flat().some((declaration) => declaration === componentToFind)) {
-        // Found component in declarations array
-        return true;
-    }
-    if (!moduleImports) {
-        return false;
-    }
-    return moduleImports.flat().some((importItem) => {
-        const extractedNgModuleMetadata = extractNgModuleMetadata(importItem);
-        if (!extractedNgModuleMetadata) {
-            // Not an NgModule
-            return false;
-        }
-        return (0, exports.isComponentAlreadyDeclared)(componentToFind, extractedNgModuleMetadata.declarations, extractedNgModuleMetadata.imports);
-    });
-};
-exports.isComponentAlreadyDeclared = isComponentAlreadyDeclared;
-const extractNgModuleMetadata = (importItem) => {
-    const target = importItem && importItem.ngModule ? importItem.ngModule : importItem;
-    const decorators = reflectionCapabilities.annotations(target);
-    if (!decorators || decorators.length === 0) {
-        return null;
-    }
-    const ngModuleDecorator = decorators.find((decorator) => decorator instanceof core_1.NgModule);
-    if (!ngModuleDecorator) {
-        return null;
-    }
-    return ngModuleDecorator;
-};

package/dist/client/angular-beta/utils/NgModulesAnalyzer.mjs

@@ -1,37 +0,0 @@
-import { NgModule, ɵReflectionCapabilities as ReflectionCapabilities } from '@angular/core';
-const reflectionCapabilities = new ReflectionCapabilities();
-/**
- * Avoid component redeclaration
- *
- * Checks recursively if the component has already been declared in all import Module
- */
-export const isComponentAlreadyDeclared = (componentToFind, moduleDeclarations, moduleImports) => {
-    if (moduleDeclarations &&
-        moduleDeclarations.flat().some((declaration) => declaration === componentToFind)) {
-        // Found component in declarations array
-        return true;
-    }
-    if (!moduleImports) {
-        return false;
-    }
-    return moduleImports.flat().some((importItem) => {
-        const extractedNgModuleMetadata = extractNgModuleMetadata(importItem);
-        if (!extractedNgModuleMetadata) {
-            // Not an NgModule
-            return false;
-        }
-        return isComponentAlreadyDeclared(componentToFind, extractedNgModuleMetadata.declarations, extractedNgModuleMetadata.imports);
-    });
-};
-const extractNgModuleMetadata = (importItem) => {
-    const target = importItem && importItem.ngModule ? importItem.ngModule : importItem;
-    const decorators = reflectionCapabilities.annotations(target);
-    if (!decorators || decorators.length === 0) {
-        return null;
-    }
-    const ngModuleDecorator = decorators.find((decorator) => decorator instanceof NgModule);
-    if (!ngModuleDecorator) {
-        return null;
-    }
-    return ngModuleDecorator;
-};

package/dist/client/angular-beta/utils/NgModulesAnalyzer.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/client/angular-beta/utils/NgModulesAnalyzer.test.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@angular/core");
-const vitest_1 = require("vitest");
-const NgModulesAnalyzer_1 = require("./NgModulesAnalyzer");
-const FooComponent = (0, core_1.Component)({})(class {
-});
-const BarComponent = (0, core_1.Component)({})(class {
-});
-const BetaModule = (0, core_1.NgModule)({ declarations: [FooComponent] })(class {
-});
-const AlphaModule = (0, core_1.NgModule)({ imports: [BetaModule] })(class {
-});
-(0, vitest_1.describe)('isComponentAlreadyDeclaredInModules', () => {
-    (0, vitest_1.it)('should return true when the component is already declared in one of modules', () => {
-        (0, vitest_1.expect)((0, NgModulesAnalyzer_1.isComponentAlreadyDeclared)(FooComponent, [], [AlphaModule])).toEqual(true);
-    });
-    (0, vitest_1.it)('should return true if the component is in moduleDeclarations', () => {
-        (0, vitest_1.expect)((0, NgModulesAnalyzer_1.isComponentAlreadyDeclared)(BarComponent, [BarComponent], [AlphaModule])).toEqual(true);
-    });
-    (0, vitest_1.it)('should return false if the component is not declared', () => {
-        (0, vitest_1.expect)((0, NgModulesAnalyzer_1.isComponentAlreadyDeclared)(BarComponent, [], [AlphaModule])).toEqual(false);
-    });
-});

package/dist/client/angular-beta/utils/NgModulesAnalyzer.test.mjs

@@ -1,22 +0,0 @@
-import { Component, NgModule } from '@angular/core';
-import { describe, expect, it } from 'vitest';
-import { isComponentAlreadyDeclared } from './NgModulesAnalyzer';
-const FooComponent = Component({})(class {
-});
-const BarComponent = Component({})(class {
-});
-const BetaModule = NgModule({ declarations: [FooComponent] })(class {
-});
-const AlphaModule = NgModule({ imports: [BetaModule] })(class {
-});
-describe('isComponentAlreadyDeclaredInModules', () => {
-    it('should return true when the component is already declared in one of modules', () => {
-        expect(isComponentAlreadyDeclared(FooComponent, [], [AlphaModule])).toEqual(true);
-    });
-    it('should return true if the component is in moduleDeclarations', () => {
-        expect(isComponentAlreadyDeclared(BarComponent, [BarComponent], [AlphaModule])).toEqual(true);
-    });
-    it('should return false if the component is not declared', () => {
-        expect(isComponentAlreadyDeclared(BarComponent, [], [AlphaModule])).toEqual(false);
-    });
-});

package/dist/client/angular-beta/utils/PropertyExtractor.d.ts

@@ -1,30 +0,0 @@
-import { InjectionToken, NgModule, Provider, ɵReflectionCapabilities as ReflectionCapabilities, importProvidersFrom } from '@angular/core';
-import { NgModuleMetadata } from '../../types';
-export declare const reflectionCapabilities: ReflectionCapabilities;
-export declare const REMOVED_MODULES: InjectionToken<unknown>;
-export declare const uniqueArray: (arr: any[]) => any[];
-export declare class PropertyExtractor implements NgModuleMetadata {
-    private metadata;
-    private component?;
-    declarations?: any[];
-    imports?: any[];
-    providers?: Provider[];
-    applicationProviders?: Array<Provider | ReturnType<typeof importProvidersFrom>>;
-    constructor(metadata: NgModuleMetadata, component?: any | undefined);
-    static warnImportsModuleWithProviders(propertyExtractor: PropertyExtractor): void;
-    init(): Promise<void>;
-    /**
-     * Analyze NgModule Metadata
-     *
-     * - Removes Restricted Imports
-     * - Extracts providers from ModuleWithProviders
-     * - Returns a new NgModuleMetadata object
-     */
-    private analyzeMetadata;
-    static analyzeRestricted: (ngModule: NgModule) => Promise<[boolean] | [boolean, Provider]>;
-    static analyzeDecorators: (component: any) => {
-        isDeclarable: boolean;
-        isStandalone: any;
-    };
-    static isDecoratorInstanceOf: (decorator: any, name: string) => boolean;
-}