@skyux/docs-tools 5.0.0-beta.7 → 6.0.0-beta.0

package/esm2020/modules/type-definitions/type-definitions-format.service.mjs

@@ -0,0 +1,242 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Formats type definitions into HTML-compatible strings.
+ */
+export class SkyDocsTypeDefinitionsFormatService {
+    /**
+     * Returns an HTML-formatted representation of the provided interface config.
+     */
+    getInterfaceSourceCode(definition) {
+        const typeParameters = this.getFormattedTypeParameters(definition.typeParameters);
+        const config = {
+            escapeSpecialCharacters: false,
+        };
+        let signature = `interface ${definition.name}${typeParameters} {`;
+        signature += this.getFormattedInterfaceProperties(definition, config);
+        signature += '\n}';
+        return signature;
+    }
+    /**
+     * Returns an HTML-formatted representation of the provided method config.
+     */
+    getMethodSourceCode(definition) {
+        const config = {
+            escapeSpecialCharacters: false,
+        };
+        const typeArguments = this.getFormattedTypeArguments(definition.type, config);
+        const callSignature = definition.type.callSignature;
+        const returnType = this.getFormattedType(callSignature.returnType, config);
+        let params = '';
+        if (callSignature.parameters) {
+            params += callSignature.parameters
+                .map((p) => this.getFormattedParameterName(p, config))
+                .join(', ');
+        }
+        return `public ${definition.name}${typeArguments}(${params}): ${returnType}`;
+    }
+    /**
+     * Returns an HTML-formatted representation of the provided type alias config.
+     */
+    getTypeAliasSourceCode(definition) {
+        const config = {
+            escapeSpecialCharacters: false,
+        };
+        const typeParameters = this.getFormattedTypeParameters(definition.typeParameters);
+        let signature = `type ${definition.name}${typeParameters} = `;
+        if (definition.type.callSignature) {
+            signature += this.getFormattedCallSignature(definition.type.callSignature, {
+                escapeSpecialCharacters: false,
+            });
+        }
+        else if (definition.type.indexSignature) {
+            const indexSignature = definition.type.indexSignature;
+            const type = this.getFormattedType(indexSignature.type, {
+                escapeSpecialCharacters: false,
+            });
+            signature += `{\n  [${indexSignature.key.name}: string]: ${type};\n}`;
+        }
+        else {
+            /*istanbul ignore else */
+            if (definition.type.type === 'union') {
+                signature += this.getFormattedUnion(definition.type, config);
+            }
+        }
+        return signature;
+    }
+    /**
+     * Returns a formatted string representing a parameter's name and value. For example: `'foo: string'`.
+     */
+    getFormattedParameterName(parameter, config = {
+        escapeSpecialCharacters: true,
+    }) {
+        const optionalMarker = parameter.isOptional ? '?' : '';
+        const parameterType = this.getFormattedType(parameter.type, config);
+        let signature = `${parameter.name}${optionalMarker}: ${parameterType}`;
+        if (config.escapeSpecialCharacters) {
+            signature = this.escapeSpecialCharacters(signature);
+        }
+        return signature;
+    }
+    /**
+     * Returns a formatted string representing a property (or method's) name and value. For example: `'public foo: string'`.
+     */
+    getFormattedPropertyName(property) {
+        let signature = '';
+        if (property.decorator?.name) {
+            signature += `@${property.decorator.name}()<br>`;
+        }
+        const indexSignature = property.type?.indexSignature;
+        let name;
+        if (indexSignature) {
+            name = `[${indexSignature.key.name}: ${this.getFormattedType(indexSignature.key.type)}]`;
+        }
+        else {
+            name = property.name;
+        }
+        if (property.deprecationWarning !== undefined) {
+            signature += `<strike>${name}</strike>`;
+        }
+        else {
+            signature += name;
+        }
+        if (property.isOptional && !indexSignature) {
+            signature += '?';
+        }
+        if (indexSignature) {
+            signature += `: ${this.getFormattedType(indexSignature.type)}`;
+        }
+        else if (property.type) {
+            signature += `: ${this.getFormattedType(property.type)}`;
+        }
+        return signature;
+    }
+    /**
+     * Returns an HTML-formatted method name to be used on the properties table.
+     */
+    getFormattedMethodName(definition) {
+        let formatted = '';
+        if (definition.deprecationWarning !== undefined) {
+            formatted += `<strike>${definition.name}</strike>`;
+        }
+        else {
+            formatted += definition.name;
+        }
+        return `${formatted}()`;
+    }
+    /**
+     * Returns a formatted string representing the provided type.
+     */
+    getFormattedType(type, config = {
+        escapeSpecialCharacters: true,
+    }) {
+        let formatted = 'any';
+        if (!type) {
+            return formatted;
+        }
+        if (type.callSignature) {
+            return this.getFormattedCallSignature(type.callSignature, config);
+        }
+        if (type.unionTypes) {
+            return this.getFormattedUnion(type, config);
+        }
+        if (type.name) {
+            formatted = type.name;
+        }
+        if (type.typeArguments) {
+            formatted += this.getFormattedTypeArguments(type, config);
+        }
+        if (type.type === 'array') {
+            formatted += '[]';
+        }
+        if (type.typeLiteral) {
+            const formattedTypeLiteral = this.getFormattedInterfaceProperties(type.typeLiteral, config)
+                .replace(/\n/g, ' ')
+                .replace(/\s\s+/g, ' ');
+            formatted = `{${formattedTypeLiteral} }`;
+        }
+        if (config.escapeSpecialCharacters) {
+            return this.escapeSpecialCharacters(formatted);
+        }
+        return formatted;
+    }
+    escapeSpecialCharacters(value) {
+        return value.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    }
+    getFormattedCallSignature(callSignature, config = {
+        escapeSpecialCharacters: true,
+    }) {
+        const returnType = this.getFormattedType(callSignature.returnType, config);
+        if (!callSignature.parameters) {
+            return `() => ${returnType}`;
+        }
+        const formattedParams = callSignature.parameters
+            .map((p) => this.getFormattedParameterName(p, config))
+            .join(', ');
+        return `(${formattedParams}) => ${returnType}`;
+    }
+    getFormattedUnion(typeConfig, config) {
+        return typeConfig.unionTypes
+            .map((t) => {
+            return this.getFormattedType(t, config);
+        })
+            .join(' | ');
+    }
+    /**
+     * Parse any type arguments e.g. `<T, F>`.
+     */
+    getFormattedTypeArguments(typeConfig, config) {
+        if (!typeConfig.typeArguments) {
+            return '';
+        }
+        const typeArguments = typeConfig.typeArguments.map((typeArgument) => {
+            if (typeArgument.type === 'array') {
+                return `${typeArgument.name}[]`;
+            }
+            if (typeArgument.unionTypes) {
+                return this.getFormattedUnion(typeArgument, config);
+            }
+            return typeArgument.name;
+        });
+        return `<${typeArguments.join(', ')}>`;
+    }
+    getFormattedTypeParameters(typeParameters) {
+        if (!typeParameters) {
+            return '';
+        }
+        const formatted = typeParameters.map((typeParameter) => {
+            let result = typeParameter.name;
+            if (typeParameter.type && typeParameter.type.type === 'reference') {
+                result += ` extends ${typeParameter.type.name}`;
+            }
+            return result;
+        });
+        return `<${formatted.join(', ')}>`;
+    }
+    getFormattedInterfaceProperties(definition, config) {
+        let signature = '';
+        definition.properties.forEach((property) => {
+            const indexSignature = property.type.indexSignature;
+            const optionalIndicator = property.isOptional && !indexSignature ? '?' : '';
+            const propertyType = this.getFormattedType(property.type, config);
+            let name;
+            if (indexSignature) {
+                name = `[${indexSignature.key.name}: string]`;
+            }
+            else {
+                name = property.name;
+            }
+            signature += `\n  ${name}${optionalIndicator}: ${propertyType};`;
+        });
+        return signature;
+    }
+}
+SkyDocsTypeDefinitionsFormatService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyDocsTypeDefinitionsFormatService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SkyDocsTypeDefinitionsFormatService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyDocsTypeDefinitionsFormatService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyDocsTypeDefinitionsFormatService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type-definitions-format.service.js","sourceRoot":"","sources":["../../../../../projects/docs-tools/src/modules/type-definitions/type-definitions-format.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { SkyDocsCallSignatureDefinition } from './call-signature-definition';\n\nimport { SkyDocsClassPropertyDefinition } from './property-definition';\n\nimport { SkyDocsInterfaceDefinition } from './interface-definition';\n\nimport { SkyDocsClassMethodDefinition } from './method-definition';\n\nimport { SkyDocsParameterDefinition } from './parameter-definition';\n\nimport { SkyDocsTypeAliasDefinition } from './type-alias-definition';\n\nimport { SkyDocsTypeDefinition } from './type-definition';\n\nimport { SkyDocsTypeParameterDefinition } from './type-parameter-definition';\n\nimport { SkyDocsInterfacePropertyDefinition } from './interface-property-definition';\n\ninterface GetFormattedTypeConfig {\n  escapeSpecialCharacters: boolean;\n}\n\n/**\n * Formats type definitions into HTML-compatible strings.\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class SkyDocsTypeDefinitionsFormatService {\n  /**\n   * Returns an HTML-formatted representation of the provided interface config.\n   */\n  public getInterfaceSourceCode(\n    definition: SkyDocsInterfaceDefinition\n  ): string {\n    const typeParameters = this.getFormattedTypeParameters(\n      definition.typeParameters\n    );\n    const config = {\n      escapeSpecialCharacters: false,\n    };\n\n    let signature: string = `interface ${definition.name}${typeParameters} {`;\n    signature += this.getFormattedInterfaceProperties(definition, config);\n    signature += '\\n}';\n\n    return signature;\n  }\n\n  /**\n   * Returns an HTML-formatted representation of the provided method config.\n   */\n  public getMethodSourceCode(definition: SkyDocsClassMethodDefinition): string {\n    const config = {\n      escapeSpecialCharacters: false,\n    };\n\n    const typeArguments = this.getFormattedTypeArguments(\n      definition.type,\n      config\n    );\n    const callSignature = definition.type.callSignature;\n    const returnType = this.getFormattedType(callSignature.returnType, config);\n\n    let params: string = '';\n    if (callSignature.parameters) {\n      params += callSignature.parameters\n        .map((p) => this.getFormattedParameterName(p, config))\n        .join(', ');\n    }\n\n    return `public ${definition.name}${typeArguments}(${params}): ${returnType}`;\n  }\n\n  /**\n   * Returns an HTML-formatted representation of the provided type alias config.\n   */\n  public getTypeAliasSourceCode(\n    definition: SkyDocsTypeAliasDefinition\n  ): string {\n    const config = {\n      escapeSpecialCharacters: false,\n    };\n\n    const typeParameters = this.getFormattedTypeParameters(\n      definition.typeParameters\n    );\n\n    let signature = `type ${definition.name}${typeParameters} = `;\n\n    if (definition.type.callSignature) {\n      signature += this.getFormattedCallSignature(\n        definition.type.callSignature,\n        {\n          escapeSpecialCharacters: false,\n        }\n      );\n    } else if (definition.type.indexSignature) {\n      const indexSignature = definition.type.indexSignature;\n      const type = this.getFormattedType(indexSignature.type, {\n        escapeSpecialCharacters: false,\n      });\n      signature += `{\\n  [${indexSignature.key.name}: string]: ${type};\\n}`;\n    } else {\n      /*istanbul ignore else */\n      if (definition.type.type === 'union') {\n        signature += this.getFormattedUnion(definition.type, config);\n      }\n    }\n\n    return signature;\n  }\n\n  /**\n   * Returns a formatted string representing a parameter's name and value. For example: `'foo: string'`.\n   */\n  public getFormattedParameterName(\n    parameter: SkyDocsParameterDefinition,\n    config: GetFormattedTypeConfig = {\n      escapeSpecialCharacters: true,\n    }\n  ): string {\n    const optionalMarker = parameter.isOptional ? '?' : '';\n    const parameterType = this.getFormattedType(parameter.type, config);\n\n    let signature = `${parameter.name}${optionalMarker}: ${parameterType}`;\n    if (config.escapeSpecialCharacters) {\n      signature = this.escapeSpecialCharacters(signature);\n    }\n\n    return signature;\n  }\n\n  /**\n   * Returns a formatted string representing a property (or method's) name and value. For example: `'public foo: string'`.\n   */\n  public getFormattedPropertyName(\n    property: SkyDocsClassPropertyDefinition\n  ): string {\n    let signature = '';\n\n    if (property.decorator?.name) {\n      signature += `@${property.decorator.name}()<br>`;\n    }\n\n    const indexSignature = property.type?.indexSignature;\n    let name: string;\n    if (indexSignature) {\n      name = `[${indexSignature.key.name}: ${this.getFormattedType(\n        indexSignature.key.type\n      )}]`;\n    } else {\n      name = property.name;\n    }\n\n    if (property.deprecationWarning !== undefined) {\n      signature += `<strike>${name}</strike>`;\n    } else {\n      signature += name;\n    }\n\n    if (property.isOptional && !indexSignature) {\n      signature += '?';\n    }\n\n    if (indexSignature) {\n      signature += `: ${this.getFormattedType(indexSignature.type)}`;\n    } else if (property.type) {\n      signature += `: ${this.getFormattedType(property.type)}`;\n    }\n\n    return signature;\n  }\n\n  /**\n   * Returns an HTML-formatted method name to be used on the properties table.\n   */\n  public getFormattedMethodName(\n    definition: SkyDocsClassMethodDefinition\n  ): string {\n    let formatted = '';\n\n    if (definition.deprecationWarning !== undefined) {\n      formatted += `<strike>${definition.name}</strike>`;\n    } else {\n      formatted += definition.name;\n    }\n\n    return `${formatted}()`;\n  }\n\n  /**\n   * Returns a formatted string representing the provided type.\n   */\n  public getFormattedType(\n    type: SkyDocsTypeDefinition,\n    config: GetFormattedTypeConfig = {\n      escapeSpecialCharacters: true,\n    }\n  ): string {\n    let formatted = 'any';\n\n    if (!type) {\n      return formatted;\n    }\n\n    if (type.callSignature) {\n      return this.getFormattedCallSignature(type.callSignature, config);\n    }\n\n    if (type.unionTypes) {\n      return this.getFormattedUnion(type, config);\n    }\n\n    if (type.name) {\n      formatted = type.name;\n    }\n\n    if (type.typeArguments) {\n      formatted += this.getFormattedTypeArguments(type, config);\n    }\n\n    if (type.type === 'array') {\n      formatted += '[]';\n    }\n\n    if (type.typeLiteral) {\n      const formattedTypeLiteral = this.getFormattedInterfaceProperties(\n        type.typeLiteral,\n        config\n      )\n        .replace(/\\n/g, ' ')\n        .replace(/\\s\\s+/g, ' ');\n      formatted = `{${formattedTypeLiteral} }`;\n    }\n\n    if (config.escapeSpecialCharacters) {\n      return this.escapeSpecialCharacters(formatted);\n    }\n\n    return formatted;\n  }\n\n  public escapeSpecialCharacters(value: string): string {\n    return value.replace(/</g, '&lt;').replace(/>/g, '&gt;');\n  }\n\n  private getFormattedCallSignature(\n    callSignature: SkyDocsCallSignatureDefinition,\n    config: GetFormattedTypeConfig = {\n      escapeSpecialCharacters: true,\n    }\n  ): string {\n    const returnType = this.getFormattedType(callSignature.returnType, config);\n\n    if (!callSignature.parameters) {\n      return `() => ${returnType}`;\n    }\n\n    const formattedParams = callSignature.parameters\n      .map((p) => this.getFormattedParameterName(p, config))\n      .join(', ');\n\n    return `(${formattedParams}) => ${returnType}`;\n  }\n\n  private getFormattedUnion(\n    typeConfig: SkyDocsTypeDefinition,\n    config: GetFormattedTypeConfig\n  ): string {\n    return typeConfig.unionTypes\n      .map((t) => {\n        return this.getFormattedType(t, config);\n      })\n      .join(' | ');\n  }\n\n  /**\n   * Parse any type arguments e.g. `<T, F>`.\n   */\n  private getFormattedTypeArguments(\n    typeConfig: SkyDocsTypeDefinition,\n    config: GetFormattedTypeConfig\n  ): string {\n    if (!typeConfig.typeArguments) {\n      return '';\n    }\n\n    const typeArguments = typeConfig.typeArguments.map((typeArgument) => {\n      if (typeArgument.type === 'array') {\n        return `${typeArgument.name}[]`;\n      }\n\n      if (typeArgument.unionTypes) {\n        return this.getFormattedUnion(typeArgument, config);\n      }\n\n      return typeArgument.name;\n    });\n\n    return `<${typeArguments.join(', ')}>`;\n  }\n\n  private getFormattedTypeParameters(\n    typeParameters: SkyDocsTypeParameterDefinition[]\n  ): string {\n    if (!typeParameters) {\n      return '';\n    }\n\n    const formatted = typeParameters.map((typeParameter) => {\n      let result = typeParameter.name;\n      if (typeParameter.type && typeParameter.type.type === 'reference') {\n        result += ` extends ${typeParameter.type.name}`;\n      }\n\n      return result;\n    });\n\n    return `<${formatted.join(', ')}>`;\n  }\n\n  private getFormattedInterfaceProperties(\n    definition: {\n      properties?: SkyDocsInterfacePropertyDefinition[];\n    },\n    config?: GetFormattedTypeConfig\n  ): string {\n    let signature: string = '';\n\n    definition.properties.forEach((property) => {\n      const indexSignature = property.type.indexSignature;\n      const optionalIndicator =\n        property.isOptional && !indexSignature ? '?' : '';\n      const propertyType = this.getFormattedType(property.type, config);\n\n      let name: string;\n      if (indexSignature) {\n        name = `[${indexSignature.key.name}: string]`;\n      } else {\n        name = property.name;\n      }\n\n      signature += `\\n  ${name}${optionalIndicator}: ${propertyType};`;\n    });\n\n    return signature;\n  }\n}\n"]}

package/esm2020/modules/type-definitions/type-definitions-provider.mjs

@@ -0,0 +1,10 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class SkyDocsTypeDefinitionsProvider {
+}
+SkyDocsTypeDefinitionsProvider.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyDocsTypeDefinitionsProvider, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SkyDocsTypeDefinitionsProvider.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyDocsTypeDefinitionsProvider });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyDocsTypeDefinitionsProvider, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS1kZWZpbml0aW9ucy1wcm92aWRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2RvY3MtdG9vbHMvc3JjL21vZHVsZXMvdHlwZS1kZWZpbml0aW9ucy90eXBlLWRlZmluaXRpb25zLXByb3ZpZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzNDLE1BQU0sT0FBTyw4QkFBOEI7OzJIQUE5Qiw4QkFBOEI7K0hBQTlCLDhCQUE4QjsyRkFBOUIsOEJBQThCO2tCQUQxQyxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBUeXBlRG9jRW50cnkgfSBmcm9tICcuL3R5cGVkb2MtdHlwZXMnO1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgU2t5RG9jc1R5cGVEZWZpbml0aW9uc1Byb3ZpZGVyIHtcbiAgcHVibGljIHJlYWRvbmx5IGFuY2hvcklkczogeyBbXzogc3RyaW5nXTogc3RyaW5nIH07XG5cbiAgcHVibGljIHJlYWRvbmx5IHR5cGVEZWZpbml0aW9uczogVHlwZURvY0VudHJ5W107XG59XG4iXX0=

package/esm2020/modules/type-definitions/type-definitions.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS1kZWZpbml0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2RvY3MtdG9vbHMvc3JjL21vZHVsZXMvdHlwZS1kZWZpbml0aW9ucy90eXBlLWRlZmluaXRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTa3lEb2NzQ2xhc3NEZWZpbml0aW9uIH0gZnJvbSAnLi9jbGFzcy1kZWZpbml0aW9uJztcblxuaW1wb3J0IHsgU2t5RG9jc0RpcmVjdGl2ZURlZmluaXRpb24gfSBmcm9tICcuL2RpcmVjdGl2ZS1kZWZpbml0aW9uJztcblxuaW1wb3J0IHsgU2t5RG9jc0VudW1lcmF0aW9uRGVmaW5pdGlvbiB9IGZyb20gJy4vZW51bWVyYXRpb24tZGVmaW5pdGlvbic7XG5cbmltcG9ydCB7IFNreURvY3NJbnRlcmZhY2VEZWZpbml0aW9uIH0gZnJvbSAnLi9pbnRlcmZhY2UtZGVmaW5pdGlvbic7XG5cbmltcG9ydCB7IFNreURvY3NQaXBlRGVmaW5pdGlvbiB9IGZyb20gJy4vcGlwZS1kZWZpbml0aW9uJztcblxuaW1wb3J0IHsgU2t5RG9jc1R5cGVBbGlhc0RlZmluaXRpb24gfSBmcm9tICcuL3R5cGUtYWxpYXMtZGVmaW5pdGlvbic7XG5cbi8qKlxuICogQGludGVybmFsXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2t5RG9jc1R5cGVEZWZpbml0aW9ucyB7XG4gIGNsYXNzZXM6IFNreURvY3NDbGFzc0RlZmluaXRpb25bXTtcblxuICBjb21wb25lbnRzOiBTa3lEb2NzRGlyZWN0aXZlRGVmaW5pdGlvbltdO1xuXG4gIGRpcmVjdGl2ZXM6IFNreURvY3NEaXJlY3RpdmVEZWZpbml0aW9uW107XG5cbiAgZW51bWVyYXRpb25zOiBTa3lEb2NzRW51bWVyYXRpb25EZWZpbml0aW9uW107XG5cbiAgaW50ZXJmYWNlczogU2t5RG9jc0ludGVyZmFjZURlZmluaXRpb25bXTtcblxuICBwaXBlczogU2t5RG9jc1BpcGVEZWZpbml0aW9uW107XG5cbiAgc2VydmljZXM6IFNreURvY3NDbGFzc0RlZmluaXRpb25bXTtcblxuICB0eXBlQWxpYXNlczogU2t5RG9jc1R5cGVBbGlhc0RlZmluaXRpb25bXTtcbn1cbiJdfQ==

package/esm2020/modules/type-definitions/type-definitions.module.mjs

@@ -0,0 +1,102 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { RouterModule } from '@angular/router';
+import { SkyCodeBlockModule, SkyCodeModule, } from '@blackbaud/skyux-lib-code-block';
+import { SkyIconModule } from '@skyux/indicators';
+import { SkyDefinitionListModule } from '@skyux/layout';
+import { SkyDocsHeadingAnchorModule } from '../heading-anchor/heading-anchor.module';
+import { SkyDocsMarkdownModule } from '../markdown/markdown.module';
+import { SkyDocsSafeHtmlModule } from '../safe-html/safe-html.module';
+import { SkyDocsCallSignatureDefinitionComponent } from './call-signature-definition.component';
+import { SkyDocsDirectiveDefinitionComponent } from './directive-definition.component';
+import { SkyDocsEnumerationDefinitionComponent } from './enumeration-definition.component';
+import { SkyDocsInterfaceDefinitionComponent } from './interface-definition.component';
+import { SkyDocsMethodDefinitionsComponent } from './method-definitions.component';
+import { SkyDocsPipeDefinitionComponent } from './pipe-definition.component';
+import { SkyDocsPropertyDefinitionsComponent } from './property-definitions.component';
+import { SkyDocsClassDefinitionComponent } from './class-definition.component';
+import { SkyDocsTypeAliasDefinitionComponent } from './type-alias-definition.component';
+import { SkyDocsTypeAnchorLinksPipe } from './type-anchor-links.pipe';
+import * as i0 from "@angular/core";
+export class SkyDocsTypeDefinitionsModule {
+}
+SkyDocsTypeDefinitionsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyDocsTypeDefinitionsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SkyDocsTypeDefinitionsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyDocsTypeDefinitionsModule, declarations: [SkyDocsCallSignatureDefinitionComponent,
+        SkyDocsClassDefinitionComponent,
+        SkyDocsDirectiveDefinitionComponent,
+        SkyDocsEnumerationDefinitionComponent,
+        SkyDocsInterfaceDefinitionComponent,
+        SkyDocsMethodDefinitionsComponent,
+        SkyDocsPipeDefinitionComponent,
+        SkyDocsPropertyDefinitionsComponent,
+        SkyDocsTypeAliasDefinitionComponent,
+        SkyDocsTypeAnchorLinksPipe], imports: [CommonModule,
+        RouterModule,
+        SkyCodeBlockModule,
+        SkyCodeModule,
+        SkyDefinitionListModule,
+        SkyDocsHeadingAnchorModule,
+        SkyDocsMarkdownModule,
+        SkyDocsSafeHtmlModule,
+        SkyIconModule], exports: [SkyDocsCallSignatureDefinitionComponent,
+        SkyDocsClassDefinitionComponent,
+        SkyDocsDirectiveDefinitionComponent,
+        SkyDocsEnumerationDefinitionComponent,
+        SkyDocsInterfaceDefinitionComponent,
+        SkyDocsMethodDefinitionsComponent,
+        SkyDocsPipeDefinitionComponent,
+        SkyDocsPropertyDefinitionsComponent,
+        SkyDocsTypeAliasDefinitionComponent,
+        SkyDocsTypeAnchorLinksPipe] });
+SkyDocsTypeDefinitionsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyDocsTypeDefinitionsModule, imports: [[
+            CommonModule,
+            RouterModule,
+            SkyCodeBlockModule,
+            SkyCodeModule,
+            SkyDefinitionListModule,
+            SkyDocsHeadingAnchorModule,
+            SkyDocsMarkdownModule,
+            SkyDocsSafeHtmlModule,
+            SkyIconModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyDocsTypeDefinitionsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        RouterModule,
+                        SkyCodeBlockModule,
+                        SkyCodeModule,
+                        SkyDefinitionListModule,
+                        SkyDocsHeadingAnchorModule,
+                        SkyDocsMarkdownModule,
+                        SkyDocsSafeHtmlModule,
+                        SkyIconModule,
+                    ],
+                    declarations: [
+                        SkyDocsCallSignatureDefinitionComponent,
+                        SkyDocsClassDefinitionComponent,
+                        SkyDocsDirectiveDefinitionComponent,
+                        SkyDocsEnumerationDefinitionComponent,
+                        SkyDocsInterfaceDefinitionComponent,
+                        SkyDocsMethodDefinitionsComponent,
+                        SkyDocsPipeDefinitionComponent,
+                        SkyDocsPropertyDefinitionsComponent,
+                        SkyDocsTypeAliasDefinitionComponent,
+                        SkyDocsTypeAnchorLinksPipe,
+                    ],
+                    exports: [
+                        SkyDocsCallSignatureDefinitionComponent,
+                        SkyDocsClassDefinitionComponent,
+                        SkyDocsDirectiveDefinitionComponent,
+                        SkyDocsEnumerationDefinitionComponent,
+                        SkyDocsInterfaceDefinitionComponent,
+                        SkyDocsMethodDefinitionsComponent,
+                        SkyDocsPipeDefinitionComponent,
+                        SkyDocsPropertyDefinitionsComponent,
+                        SkyDocsTypeAliasDefinitionComponent,
+                        SkyDocsTypeAnchorLinksPipe,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/modules/type-definitions/type-definitions.service.mjs

@@ -0,0 +1,103 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./type-definitions-provider";
+import * as i2 from "./typedoc-adapter.service";
+/**
+ * Handles all type definitions that have been converted from the third-party documentation generator.
+ */
+export class SkyDocsTypeDefinitionsService {
+    constructor(typeDefinitionsProvider, adapter) {
+        this.typeDefinitionsProvider = typeDefinitionsProvider;
+        this.adapter = adapter;
+    }
+    /**
+     * Returns type definitions from a specific source code location.
+     * @param sourceCodePath The directory of the source code you wish to pull type definitions from,
+     * relative to the application's root directory.
+     */
+    getTypeDefinitions(sourceCodePath, additionalSourceCodePaths) {
+        if (!sourceCodePath) {
+            throw new Error('The `sourceCodePath` parameter is required');
+        }
+        const sourceCodePaths = additionalSourceCodePaths && additionalSourceCodePaths.length > 0
+            ? [sourceCodePath].concat(additionalSourceCodePaths)
+            : [sourceCodePath];
+        sourceCodePaths.forEach((path) => {
+            if (!path.endsWith('/') && !path.endsWith('.ts')) {
+                throw new Error('Source code paths must end with a forward slash (`/`) or `.ts`.');
+            }
+        });
+        const allDefinitions = this.typeDefinitionsProvider.typeDefinitions;
+        const types = {
+            classes: [],
+            components: [],
+            directives: [],
+            enumerations: [],
+            interfaces: [],
+            pipes: [],
+            services: [],
+            typeAliases: [],
+        };
+        if (!allDefinitions) {
+            console.warn(`No types were found for this project!`);
+            return types;
+        }
+        sourceCodePaths.forEach((path) => {
+            const requestedDir = path
+                .replace(/src\/app\/public\//, '')
+                .replace(/^\//, ''); // remove first slash.
+            // Only process types that match the requested source code location.
+            const typeDefinitions = allDefinitions.filter((i) => i.sources && i.sources[0].fileName.match(requestedDir));
+            if (typeDefinitions.length === 0) {
+                console.warn(`Type definitions were not found for location: ${requestedDir}`);
+            }
+            typeDefinitions.forEach((item) => {
+                const decorator = item.decorators && item.decorators[0].name;
+                const kindString = item.kindString;
+                switch (decorator) {
+                    case 'Component':
+                        types.components.push(this.adapter.toDirectiveDefinition(item));
+                        break;
+                    case 'Directive':
+                        types.directives.push(this.adapter.toDirectiveDefinition(item));
+                        break;
+                    case 'Injectable':
+                        types.services.push(this.adapter.toClassDefinition(item));
+                        break;
+                    case 'NgModule':
+                        // Don't document modules.
+                        break;
+                    case 'Pipe':
+                        types.pipes.push(this.adapter.toPipeDefinition(item));
+                        break;
+                    default:
+                        /*tslint:disable-next-line:switch-default*/
+                        switch (kindString) {
+                            case 'Class':
+                                types.classes.push(this.adapter.toClassDefinition(item));
+                                break;
+                            case 'Interface':
+                                types.interfaces.push(this.adapter.toInterfaceDefinition(item));
+                                break;
+                            case 'Enumeration':
+                                types.enumerations.push(this.adapter.toEnumerationDefinition(item));
+                                break;
+                            case 'Type alias':
+                                types.typeAliases.push(this.adapter.toTypeAliasDefinition(item));
+                                break;
+                        }
+                }
+            });
+        });
+        return types;
+    }
+}
+SkyDocsTypeDefinitionsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyDocsTypeDefinitionsService, deps: [{ token: i1.SkyDocsTypeDefinitionsProvider }, { token: i2.SkyDocsTypeDocAdapterService }], target: i0.ɵɵFactoryTarget.Injectable });
+SkyDocsTypeDefinitionsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyDocsTypeDefinitionsService, providedIn: 'any' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyDocsTypeDefinitionsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'any',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SkyDocsTypeDefinitionsProvider }, { type: i2.SkyDocsTypeDocAdapterService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"type-definitions.service.js","sourceRoot":"","sources":["../../../../../projects/docs-tools/src/modules/type-definitions/type-definitions.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { SkyDocsTypeDefinitions } from './type-definitions';\n\nimport { SkyDocsTypeDefinitionsProvider } from './type-definitions-provider';\n\nimport { SkyDocsTypeDocAdapterService } from './typedoc-adapter.service';\n\n/**\n * Handles all type definitions that have been converted from the third-party documentation generator.\n */\n@Injectable({\n  providedIn: 'any',\n})\nexport class SkyDocsTypeDefinitionsService {\n  constructor(\n    private typeDefinitionsProvider: SkyDocsTypeDefinitionsProvider,\n    private adapter: SkyDocsTypeDocAdapterService\n  ) {}\n\n  /**\n   * Returns type definitions from a specific source code location.\n   * @param sourceCodePath The directory of the source code you wish to pull type definitions from,\n   * relative to the application's root directory.\n   */\n  public getTypeDefinitions(\n    sourceCodePath: string,\n    additionalSourceCodePaths?: string[]\n  ): SkyDocsTypeDefinitions {\n    if (!sourceCodePath) {\n      throw new Error('The `sourceCodePath` parameter is required');\n    }\n\n    const sourceCodePaths: string[] =\n      additionalSourceCodePaths && additionalSourceCodePaths.length > 0\n        ? [sourceCodePath].concat(additionalSourceCodePaths)\n        : [sourceCodePath];\n\n    sourceCodePaths.forEach((path) => {\n      if (!path.endsWith('/') && !path.endsWith('.ts')) {\n        throw new Error(\n          'Source code paths must end with a forward slash (`/`) or `.ts`.'\n        );\n      }\n    });\n\n    const allDefinitions = this.typeDefinitionsProvider.typeDefinitions;\n    const types: SkyDocsTypeDefinitions = {\n      classes: [],\n      components: [],\n      directives: [],\n      enumerations: [],\n      interfaces: [],\n      pipes: [],\n      services: [],\n      typeAliases: [],\n    };\n\n    if (!allDefinitions) {\n      console.warn(`No types were found for this project!`);\n      return types;\n    }\n\n    sourceCodePaths.forEach((path) => {\n      const requestedDir = path\n        .replace(/src\\/app\\/public\\//, '')\n        .replace(/^\\//, ''); // remove first slash.\n\n      // Only process types that match the requested source code location.\n      const typeDefinitions = allDefinitions.filter(\n        (i) => i.sources && i.sources[0].fileName.match(requestedDir)\n      );\n      if (typeDefinitions.length === 0) {\n        console.warn(\n          `Type definitions were not found for location: ${requestedDir}`\n        );\n      }\n\n      typeDefinitions.forEach((item) => {\n        const decorator = item.decorators && item.decorators[0].name;\n        const kindString = item.kindString;\n\n        switch (decorator) {\n          case 'Component':\n            types.components.push(this.adapter.toDirectiveDefinition(item));\n            break;\n          case 'Directive':\n            types.directives.push(this.adapter.toDirectiveDefinition(item));\n            break;\n          case 'Injectable':\n            types.services.push(this.adapter.toClassDefinition(item));\n            break;\n          case 'NgModule':\n            // Don't document modules.\n            break;\n          case 'Pipe':\n            types.pipes.push(this.adapter.toPipeDefinition(item));\n            break;\n          default:\n            /*tslint:disable-next-line:switch-default*/\n            switch (kindString) {\n              case 'Class':\n                types.classes.push(this.adapter.toClassDefinition(item));\n                break;\n              case 'Interface':\n                types.interfaces.push(this.adapter.toInterfaceDefinition(item));\n                break;\n              case 'Enumeration':\n                types.enumerations.push(\n                  this.adapter.toEnumerationDefinition(item)\n                );\n                break;\n              case 'Type alias':\n                types.typeAliases.push(\n                  this.adapter.toTypeAliasDefinition(item)\n                );\n                break;\n            }\n        }\n      });\n    });\n\n    return types;\n  }\n}\n"]}

package/esm2020/modules/type-definitions/type-parameter-definition.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZS1wYXJhbWV0ZXItZGVmaW5pdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2RvY3MtdG9vbHMvc3JjL21vZHVsZXMvdHlwZS1kZWZpbml0aW9ucy90eXBlLXBhcmFtZXRlci1kZWZpbml0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTa3lEb2NzVHlwZURlZmluaXRpb24gfSBmcm9tICcuL3R5cGUtZGVmaW5pdGlvbic7XG5cbi8qKlxuICogRGVzY3JpYmVzIGEgdHlwZSBwYXJhbWV0ZXIsIGUuZy4gYDxUPmAuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2t5RG9jc1R5cGVQYXJhbWV0ZXJEZWZpbml0aW9uIHtcbiAgbmFtZTogc3RyaW5nO1xuXG4gIHR5cGU/OiBTa3lEb2NzVHlwZURlZmluaXRpb247XG59XG4iXX0=