@storybook/angular 0.0.0-pr-23609-sha-f47ef339

package/dist/client/docs/compodoc.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractComponentDescription = exports.extractArgTypes = exports.extractArgTypesFromData = exports.extractType = exports.findComponentByName = exports.checkValidCompodocJson = exports.checkValidComponentOrDirective = exports.getCompodocJson = exports.setCompodocJson = exports.isMethod = void 0;
+/* eslint-disable no-underscore-dangle */
+const global_1 = require("@storybook/global");
+const client_logger_1 = require("@storybook/client-logger");
+const isMethod = (methodOrProp) => {
+    return methodOrProp.args !== undefined;
+};
+exports.isMethod = isMethod;
+const setCompodocJson = (compodocJson) => {
+    global_1.global.__STORYBOOK_COMPODOC_JSON__ = compodocJson;
+};
+exports.setCompodocJson = setCompodocJson;
+const getCompodocJson = () => global_1.global.__STORYBOOK_COMPODOC_JSON__;
+exports.getCompodocJson = getCompodocJson;
+const checkValidComponentOrDirective = (component) => {
+    if (!component.name) {
+        throw new Error(`Invalid component ${JSON.stringify(component)}`);
+    }
+};
+exports.checkValidComponentOrDirective = checkValidComponentOrDirective;
+const checkValidCompodocJson = (compodocJson) => {
+    if (!compodocJson || !compodocJson.components) {
+        throw new Error('Invalid compodoc JSON');
+    }
+};
+exports.checkValidCompodocJson = checkValidCompodocJson;
+const hasDecorator = (item, decoratorName) => item.decorators && item.decorators.find((x) => x.name === decoratorName);
+const mapPropertyToSection = (item) => {
+    if (hasDecorator(item, 'ViewChild')) {
+        return 'view child';
+    }
+    if (hasDecorator(item, 'ViewChildren')) {
+        return 'view children';
+    }
+    if (hasDecorator(item, 'ContentChild')) {
+        return 'content child';
+    }
+    if (hasDecorator(item, 'ContentChildren')) {
+        return 'content children';
+    }
+    return 'properties';
+};
+const mapItemToSection = (key, item) => {
+    switch (key) {
+        case 'methods':
+        case 'methodsClass':
+            return 'methods';
+        case 'inputsClass':
+            return 'inputs';
+        case 'outputsClass':
+            return 'outputs';
+        case 'properties':
+        case 'propertiesClass':
+            if ((0, exports.isMethod)(item)) {
+                throw new Error("Cannot be of type Method if key === 'propertiesClass'");
+            }
+            return mapPropertyToSection(item);
+        default:
+            throw new Error(`Unknown key: ${key}`);
+    }
+};
+const findComponentByName = (name, compodocJson) => compodocJson.components.find((c) => c.name === name) ||
+    compodocJson.directives.find((c) => c.name === name) ||
+    compodocJson.pipes.find((c) => c.name === name) ||
+    compodocJson.injectables.find((c) => c.name === name) ||
+    compodocJson.classes.find((c) => c.name === name);
+exports.findComponentByName = findComponentByName;
+const getComponentData = (component) => {
+    if (!component) {
+        return null;
+    }
+    (0, exports.checkValidComponentOrDirective)(component);
+    const compodocJson = (0, exports.getCompodocJson)();
+    if (!compodocJson) {
+        return null;
+    }
+    (0, exports.checkValidCompodocJson)(compodocJson);
+    const { name } = component;
+    const metadata = (0, exports.findComponentByName)(name, compodocJson);
+    if (!metadata) {
+        client_logger_1.logger.warn(`Component not found in compodoc JSON: '${name}'`);
+    }
+    return metadata;
+};
+const displaySignature = (item) => {
+    const args = item.args.map((arg) => `${arg.name}${arg.optional ? '?' : ''}: ${arg.type}`);
+    return `(${args.join(', ')}) => ${item.returnType}`;
+};
+const extractTypeFromValue = (defaultValue) => {
+    const valueType = typeof defaultValue;
+    return defaultValue || valueType === 'number' || valueType === 'boolean' || valueType === 'string'
+        ? valueType
+        : null;
+};
+const extractEnumValues = (compodocType) => {
+    const compodocJson = (0, exports.getCompodocJson)();
+    const enumType = compodocJson?.miscellaneous?.enumerations?.find((x) => x.name === compodocType);
+    if (enumType?.childs.every((x) => x.value)) {
+        return enumType.childs.map((x) => x.value);
+    }
+    if (typeof compodocType !== 'string' || compodocType.indexOf('|') === -1) {
+        return null;
+    }
+    try {
+        return compodocType.split('|').map((value) => JSON.parse(value));
+    }
+    catch (e) {
+        return null;
+    }
+};
+const extractType = (property, defaultValue) => {
+    const compodocType = property.type || extractTypeFromValue(defaultValue);
+    switch (compodocType) {
+        case 'string':
+        case 'boolean':
+        case 'number':
+            return { name: compodocType };
+        case undefined:
+        case null:
+            return { name: 'other', value: 'void' };
+        default: {
+            const resolvedType = resolveTypealias(compodocType);
+            const enumValues = extractEnumValues(resolvedType);
+            return enumValues
+                ? { name: 'enum', value: enumValues }
+                : { name: 'other', value: 'empty-enum' };
+        }
+    }
+};
+exports.extractType = extractType;
+const castDefaultValue = (property, defaultValue) => {
+    const compodocType = property.type;
+    // All these checks are necessary as compodoc does not always set the type ie. @HostBinding have empty types.
+    // null and undefined also have 'any' type
+    if (['boolean', 'number', 'string', 'EventEmitter'].includes(compodocType)) {
+        switch (compodocType) {
+            case 'boolean':
+                return defaultValue === 'true';
+            case 'number':
+                return Number(defaultValue);
+            case 'EventEmitter':
+                return undefined;
+            default:
+                return defaultValue;
+        }
+    }
+    else {
+        switch (defaultValue) {
+            case 'true':
+                return true;
+            case 'false':
+                return false;
+            case 'null':
+                return null;
+            case 'undefined':
+                return undefined;
+            default:
+                return defaultValue;
+        }
+    }
+};
+const extractDefaultValueFromComments = (property, value) => {
+    let commentValue = value;
+    property.jsdoctags.forEach((tag) => {
+        if (['default', 'defaultvalue'].includes(tag.tagName.escapedText)) {
+            const dom = new global_1.global.DOMParser().parseFromString(tag.comment, 'text/html');
+            commentValue = dom.body.textContent;
+        }
+    });
+    return commentValue;
+};
+const extractDefaultValue = (property) => {
+    try {
+        let value = property.defaultValue?.replace(/^'(.*)'$/, '$1');
+        value = castDefaultValue(property, value);
+        if (value == null && property.jsdoctags?.length > 0) {
+            value = extractDefaultValueFromComments(property, value);
+        }
+        return value;
+    }
+    catch (err) {
+        client_logger_1.logger.debug(`Error extracting ${property.name}: ${property.defaultValue}`);
+        return undefined;
+    }
+};
+const resolveTypealias = (compodocType) => {
+    const compodocJson = (0, exports.getCompodocJson)();
+    const typeAlias = compodocJson?.miscellaneous?.typealiases?.find((x) => x.name === compodocType);
+    return typeAlias ? resolveTypealias(typeAlias.rawtype) : compodocType;
+};
+const extractArgTypesFromData = (componentData) => {
+    const sectionToItems = {};
+    const compodocClasses = ['component', 'directive'].includes(componentData.type)
+        ? ['propertiesClass', 'methodsClass', 'inputsClass', 'outputsClass']
+        : ['properties', 'methods'];
+    compodocClasses.forEach((key) => {
+        const data = componentData[key] || [];
+        data.forEach((item) => {
+            const section = mapItemToSection(key, item);
+            const defaultValue = (0, exports.isMethod)(item) ? undefined : extractDefaultValue(item);
+            const type = (0, exports.isMethod)(item) || (section !== 'inputs' && section !== 'properties')
+                ? { name: 'other', value: 'void' }
+                : (0, exports.extractType)(item, defaultValue);
+            const action = section === 'outputs' ? { action: item.name } : {};
+            const argType = {
+                name: item.name,
+                description: item.rawdescription || item.description,
+                type,
+                ...action,
+                table: {
+                    category: section,
+                    type: {
+                        summary: (0, exports.isMethod)(item) ? displaySignature(item) : item.type,
+                        required: (0, exports.isMethod)(item) ? false : !item.optional,
+                    },
+                    defaultValue: { summary: defaultValue },
+                },
+            };
+            if (!sectionToItems[section]) {
+                sectionToItems[section] = [];
+            }
+            sectionToItems[section].push(argType);
+        });
+    });
+    const SECTIONS = [
+        'properties',
+        'inputs',
+        'outputs',
+        'methods',
+        'view child',
+        'view children',
+        'content child',
+        'content children',
+    ];
+    const argTypes = {};
+    SECTIONS.forEach((section) => {
+        const items = sectionToItems[section];
+        if (items) {
+            items.forEach((argType) => {
+                argTypes[argType.name] = argType;
+            });
+        }
+    });
+    return argTypes;
+};
+exports.extractArgTypesFromData = extractArgTypesFromData;
+const extractArgTypes = (component) => {
+    const componentData = getComponentData(component);
+    return componentData && (0, exports.extractArgTypesFromData)(componentData);
+};
+exports.extractArgTypes = extractArgTypes;
+const extractComponentDescription = (component) => {
+    const componentData = getComponentData(component);
+    return componentData && (componentData.rawdescription || componentData.description);
+};
+exports.extractComponentDescription = extractComponentDescription;

package/dist/client/docs/compodoc.test.d.ts

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

package/dist/client/docs/compodoc.test.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const compodoc_1 = require("./compodoc");
+const makeProperty = (compodocType) => ({
+    type: compodocType,
+    name: 'dummy',
+    decorators: [],
+    optional: true,
+});
+const getDummyCompodocJson = () => {
+    return {
+        miscellaneous: {
+            typealiases: [
+                {
+                    name: 'EnumAlias',
+                    ctype: 'miscellaneous',
+                    subtype: 'typealias',
+                    rawtype: 'EnumNumeric',
+                    file: 'src/stories/component-with-enums/enums.component.ts',
+                    description: '',
+                    kind: 161,
+                },
+                {
+                    name: 'TypeAlias',
+                    ctype: 'miscellaneous',
+                    subtype: 'typealias',
+                    rawtype: '"Type Alias 1" | "Type Alias 2" | "Type Alias 3"',
+                    file: 'src/stories/component-with-enums/enums.component.ts',
+                    description: '',
+                    kind: 168,
+                },
+            ],
+            enumerations: [
+                {
+                    name: 'EnumNumeric',
+                    childs: [
+                        {
+                            name: 'FIRST',
+                        },
+                        {
+                            name: 'SECOND',
+                        },
+                        {
+                            name: 'THIRD',
+                        },
+                    ],
+                    ctype: 'miscellaneous',
+                    subtype: 'enum',
+                    description: '<p>Button Priority</p>\n',
+                    file: 'src/stories/component-with-enums/enums.component.ts',
+                },
+                {
+                    name: 'EnumNumericInitial',
+                    childs: [
+                        {
+                            name: 'UNO',
+                            value: '1',
+                        },
+                        {
+                            name: 'DOS',
+                        },
+                        {
+                            name: 'TRES',
+                        },
+                    ],
+                    ctype: 'miscellaneous',
+                    subtype: 'enum',
+                    description: '',
+                    file: 'src/stories/component-with-enums/enums.component.ts',
+                },
+                {
+                    name: 'EnumStringValues',
+                    childs: [
+                        {
+                            name: 'PRIMARY',
+                            value: 'PRIMARY',
+                        },
+                        {
+                            name: 'SECONDARY',
+                            value: 'SECONDARY',
+                        },
+                        {
+                            name: 'TERTIARY',
+                            value: 'TERTIARY',
+                        },
+                    ],
+                    ctype: 'miscellaneous',
+                    subtype: 'enum',
+                    description: '',
+                    file: 'src/stories/component-with-enums/enums.component.ts',
+                },
+            ],
+        },
+    };
+};
+describe('extractType', () => {
+    describe('with compodoc type', () => {
+        (0, compodoc_1.setCompodocJson)(getDummyCompodocJson());
+        it.each([
+            ['string', { name: 'string' }],
+            ['boolean', { name: 'boolean' }],
+            ['number', { name: 'number' }],
+            // ['object', { name: 'object' }], // seems to be wrong | TODO: REVISIT
+            // ['foo', { name: 'other', value: 'empty-enum' }], // seems to be wrong | TODO: REVISIT
+            [null, { name: 'other', value: 'void' }],
+            [undefined, { name: 'other', value: 'void' }],
+            // ['T[]', { name: 'other', value: 'empty-enum' }], // seems to be wrong | TODO: REVISIT
+            ['[]', { name: 'other', value: 'empty-enum' }],
+            ['"primary" | "secondary"', { name: 'enum', value: ['primary', 'secondary'] }],
+            ['TypeAlias', { name: 'enum', value: ['Type Alias 1', 'Type Alias 2', 'Type Alias 3'] }],
+            // ['EnumNumeric', { name: 'other', value: 'empty-enum' }], // seems to be wrong | TODO: REVISIT
+            // ['EnumNumericInitial', { name: 'other', value: 'empty-enum' }], // seems to be wrong | TODO: REVISIT
+            ['EnumStringValues', { name: 'enum', value: ['PRIMARY', 'SECONDARY', 'TERTIARY'] }],
+        ])('%s', (compodocType, expected) => {
+            expect((0, compodoc_1.extractType)(makeProperty(compodocType), null)).toEqual(expected);
+        });
+    });
+    describe('without compodoc type', () => {
+        it.each([
+            ['string', { name: 'string' }],
+            ['', { name: 'string' }],
+            [false, { name: 'boolean' }],
+            [10, { name: 'number' }],
+            // [['abc'], { name: 'object' }], // seems to be wrong | TODO: REVISIT
+            // [{ foo: 1 }, { name: 'other', value: 'empty-enum' }], // seems to be wrong | TODO: REVISIT
+            [undefined, { name: 'other', value: 'void' }],
+        ])('%s', (defaultValue, expected) => {
+            expect((0, compodoc_1.extractType)(makeProperty(null), defaultValue)).toEqual(expected);
+        });
+    });
+});

package/dist/client/docs/config.d.ts

@@ -0,0 +1,4 @@
+import { Parameters, DecoratorFunction, ArgTypesEnhancer } from '@storybook/types';
+export declare const parameters: Parameters;
+export declare const decorators: DecoratorFunction[];
+export declare const argTypesEnhancers: ArgTypesEnhancer[];

package/dist/client/docs/config.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.argTypesEnhancers = exports.decorators = exports.parameters = void 0;
+const docs_tools_1 = require("@storybook/docs-tools");
+const compodoc_1 = require("./compodoc");
+const sourceDecorator_1 = require("./sourceDecorator");
+exports.parameters = {
+    docs: {
+        story: { inline: true },
+        extractArgTypes: compodoc_1.extractArgTypes,
+        extractComponentDescription: compodoc_1.extractComponentDescription,
+        source: {
+            type: docs_tools_1.SourceType.DYNAMIC,
+            language: 'html',
+        },
+    },
+};
+exports.decorators = [sourceDecorator_1.sourceDecorator];
+exports.argTypesEnhancers = [docs_tools_1.enhanceArgTypes];

package/dist/client/docs/index.d.ts

@@ -0,0 +1 @@
+export * from './compodoc';

package/dist/client/docs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./compodoc"), exports);

package/dist/client/docs/sourceDecorator.d.ts

@@ -0,0 +1,9 @@
+import { PartialStoryFn } from '@storybook/types';
+import { StoryContext, AngularRenderer } from '../types';
+export declare const skipSourceRender: (context: StoryContext) => any;
+/**
+ * Angular source decorator.
+ * @param storyFn Fn
+ * @param context  StoryContext
+ */
+export declare const sourceDecorator: (storyFn: PartialStoryFn<AngularRenderer>, context: StoryContext) => import("../types").StoryFnAngularReturnType;

package/dist/client/docs/sourceDecorator.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sourceDecorator = exports.skipSourceRender = void 0;
+const preview_api_1 = require("@storybook/preview-api");
+const docs_tools_1 = require("@storybook/docs-tools");
+const renderer_1 = require("../../renderer");
+const skipSourceRender = (context) => {
+    const sourceParams = context?.parameters.docs?.source;
+    // always render if the user forces it
+    if (sourceParams?.type === docs_tools_1.SourceType.DYNAMIC) {
+        return false;
+    }
+    // never render if the user is forcing the block to render code, or
+    // if the user provides code
+    return sourceParams?.code || sourceParams?.type === docs_tools_1.SourceType.CODE;
+};
+exports.skipSourceRender = skipSourceRender;
+/**
+ * Angular source decorator.
+ * @param storyFn Fn
+ * @param context  StoryContext
+ */
+const sourceDecorator = (storyFn, context) => {
+    const story = storyFn();
+    if ((0, exports.skipSourceRender)(context)) {
+        return story;
+    }
+    const channel = preview_api_1.addons.getChannel();
+    const { props, template, userDefinedTemplate } = story;
+    const { component, argTypes } = context;
+    let toEmit;
+    (0, preview_api_1.useEffect)(() => {
+        if (toEmit) {
+            const { id, unmappedArgs } = context;
+            channel.emit(docs_tools_1.SNIPPET_RENDERED, { id, args: unmappedArgs, source: toEmit, format: 'angular' });
+        }
+    });
+    if (component && !userDefinedTemplate) {
+        const source = (0, renderer_1.computesTemplateSourceFromComponent)(component, props, argTypes);
+        // We might have a story with a Directive or Service defined as the component
+        // In these cases there might exist a template, even if we aren't able to create source from component
+        if (source || template) {
+            toEmit = source || template;
+        }
+    }
+    else if (template) {
+        toEmit = template;
+    }
+    return story;
+};
+exports.sourceDecorator = sourceDecorator;

package/dist/client/docs/types.d.ts

@@ -0,0 +1,102 @@
+export interface Method {
+    name: string;
+    args: Argument[];
+    returnType: string;
+    decorators?: Decorator[];
+    description?: string;
+    rawdescription?: string;
+}
+export interface JsDocTag {
+    comment?: string;
+    tagName?: {
+        escapedText?: string;
+    };
+}
+export interface Property {
+    name: string;
+    decorators?: Decorator[];
+    type: string;
+    optional: boolean;
+    defaultValue?: string;
+    description?: string;
+    rawdescription?: string;
+    jsdoctags?: JsDocTag[];
+}
+export interface Class {
+    name: string;
+    ngname: string;
+    type: 'pipe';
+    properties: Property[];
+    methods: Method[];
+    description?: string;
+    rawdescription?: string;
+}
+export interface Injectable {
+    name: string;
+    type: 'injectable';
+    properties: Property[];
+    methods: Method[];
+    description?: string;
+    rawdescription?: string;
+}
+export interface Pipe {
+    name: string;
+    type: 'class';
+    properties: Property[];
+    methods: Method[];
+    description?: string;
+    rawdescription?: string;
+}
+export interface Directive {
+    name: string;
+    type: 'directive' | 'component';
+    propertiesClass: Property[];
+    inputsClass: Property[];
+    outputsClass: Property[];
+    methodsClass: Method[];
+    description?: string;
+    rawdescription?: string;
+}
+export type Component = Directive;
+export interface Argument {
+    name: string;
+    type: string;
+    optional?: boolean;
+}
+export interface Decorator {
+    name: string;
+}
+export interface TypeAlias {
+    name: string;
+    ctype: string;
+    subtype: string;
+    rawtype: string;
+    file: string;
+    kind: number;
+    description?: string;
+    rawdescription?: string;
+}
+export interface EnumType {
+    name: string;
+    childs: EnumTypeChild[];
+    ctype: string;
+    subtype: string;
+    file: string;
+    description?: string;
+    rawdescription?: string;
+}
+export interface EnumTypeChild {
+    name: string;
+    value?: string;
+}
+export interface CompodocJson {
+    directives: Directive[];
+    components: Component[];
+    pipes: Pipe[];
+    injectables: Injectable[];
+    classes: Class[];
+    miscellaneous?: {
+        typealiases?: TypeAlias[];
+        enumerations?: EnumType[];
+    };
+}

package/dist/client/docs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/client/globals.d.ts

@@ -0,0 +1,23 @@
+/**
+ * This file includes polyfills needed by Angular and is loaded before the app.
+ * You can add your own extra polyfills to this file.
+ *
+ * This file is divided into 2 sections:
+ *   1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers.
+ *   2. Application imports. Files imported after ZoneJS that should be loaded before your main
+ *      file.
+ *
+ * The current setup is for so-called "evergreen" browsers; the last versions of browsers that
+ * automatically update themselves. This includes Safari >= 10, Chrome >= 55 (including Opera),
+ * Edge >= 13 on the desktop, and iOS 10 and Chrome on mobile.
+ *
+ * Learn more in https://angular.io/docs/ts/latest/guide/browser-support.html
+ */
+/**
+ * Required to support Web Animations `@angular/animation`.
+ * Needed for: All but Chrome, Firefox and Opera. http://caniuse.com/#feat=web-animation
+ * */
+/** *************************************************************************************************
+ * Zone JS is required by Angular itself.
+ */
+import 'zone.js/dist/zone';

package/dist/client/globals.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const global_1 = require("@storybook/global");
+/**
+ * This file includes polyfills needed by Angular and is loaded before the app.
+ * You can add your own extra polyfills to this file.
+ *
+ * This file is divided into 2 sections:
+ *   1. Browser polyfills. These are applied before loading ZoneJS and are sorted by browsers.
+ *   2. Application imports. Files imported after ZoneJS that should be loaded before your main
+ *      file.
+ *
+ * The current setup is for so-called "evergreen" browsers; the last versions of browsers that
+ * automatically update themselves. This includes Safari >= 10, Chrome >= 55 (including Opera),
+ * Edge >= 13 on the desktop, and iOS 10 and Chrome on mobile.
+ *
+ * Learn more in https://angular.io/docs/ts/latest/guide/browser-support.html
+ */
+/**
+ * Required to support Web Animations `@angular/animation`.
+ * Needed for: All but Chrome, Firefox and Opera. http://caniuse.com/#feat=web-animation
+ * */
+// import 'web-animations-js';  // Run `npm install --save web-animations-js`.
+/** *************************************************************************************************
+ * Zone JS is required by Angular itself.
+ */
+require("zone.js/dist/zone"); // Included with Angular CLI.
+/** *************************************************************************************************
+ * APPLICATION IMPORTS
+ */
+/**
+ * Date, currency, decimal and percent pipes.
+ * Needed for: All but Chrome, Firefox, Edge, IE11 and Safari 10
+ */
+// import 'intl';  // Run `npm install --save intl`.
+/**
+ * Need to import at least one locale-data with intl.
+ */
+// import 'intl/locale-data/jsonp/en';
+global_1.global.STORYBOOK_ENV = 'angular';

package/dist/client/index.d.ts

@@ -0,0 +1,5 @@
+import './globals';
+export * from './public-api';
+export * from './public-types';
+export type { StoryFnAngularReturnType as IStory } from './types';
+export { moduleMetadata, componentWrapperDecorator, applicationConfig } from './decorators';