@skyux/docs-tools 9.0.0-alpha.0 → 9.0.0-alpha.2

package/fesm2022/skyux-docs-tools.mjs

@@ -1479,9 +1479,7 @@ class SkyDocsTypeDefinitionsFormatService {
     escapeSpecialCharacters(value) {
         return value.replace(/</g, '&lt;').replace(/>/g, '&gt;');
     }
-    getFormattedCallSignature(callSignature, config = {
-        escapeSpecialCharacters: true,
-    }) {
+    getFormattedCallSignature(callSignature, config) {
         const returnType = this.getFormattedType(callSignature.returnType, config);
         if (!callSignature.parameters) {
             return `() => ${returnType}`;
@@ -2197,6 +2195,40 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.8", ngImpor
                 }]
         }], ctorParameters: function () { return [{ type: i1$4.Title }]; } });
 
+/**
+ * This enum comes from:
+ * https://github.com/TypeStrong/typedoc/blob/v0.24.8/src/lib/models/reflections/kind.ts
+ * The enum is up to date as of version `0.24.8`.
+ */
+var TypeDocKind;
+(function (TypeDocKind) {
+    TypeDocKind[TypeDocKind["Project"] = 1] = "Project";
+    TypeDocKind[TypeDocKind["Module"] = 2] = "Module";
+    TypeDocKind[TypeDocKind["Namespace"] = 4] = "Namespace";
+    TypeDocKind[TypeDocKind["Enum"] = 8] = "Enum";
+    TypeDocKind[TypeDocKind["EnumMember"] = 16] = "EnumMember";
+    TypeDocKind[TypeDocKind["Variable"] = 32] = "Variable";
+    TypeDocKind[TypeDocKind["Function"] = 64] = "Function";
+    TypeDocKind[TypeDocKind["Class"] = 128] = "Class";
+    TypeDocKind[TypeDocKind["Interface"] = 256] = "Interface";
+    TypeDocKind[TypeDocKind["Constructor"] = 512] = "Constructor";
+    TypeDocKind[TypeDocKind["Property"] = 1024] = "Property";
+    TypeDocKind[TypeDocKind["Method"] = 2048] = "Method";
+    TypeDocKind[TypeDocKind["CallSignature"] = 4096] = "CallSignature";
+    TypeDocKind[TypeDocKind["IndexSignature"] = 8192] = "IndexSignature";
+    TypeDocKind[TypeDocKind["ConstructorSignature"] = 16384] = "ConstructorSignature";
+    TypeDocKind[TypeDocKind["Parameter"] = 32768] = "Parameter";
+    TypeDocKind[TypeDocKind["TypeLiteral"] = 65536] = "TypeLiteral";
+    TypeDocKind[TypeDocKind["TypeParameter"] = 131072] = "TypeParameter";
+    TypeDocKind[TypeDocKind["Accessor"] = 262144] = "Accessor";
+    TypeDocKind[TypeDocKind["GetSignature"] = 524288] = "GetSignature";
+    TypeDocKind[TypeDocKind["SetSignature"] = 1048576] = "SetSignature";
+    /** @deprecated will be removed in v0.25, not used */
+    TypeDocKind[TypeDocKind["ObjectLiteral"] = 2097152] = "ObjectLiteral";
+    TypeDocKind[TypeDocKind["TypeAlias"] = 4194304] = "TypeAlias";
+    TypeDocKind[TypeDocKind["Reference"] = 8388608] = "Reference";
+})(TypeDocKind || (TypeDocKind = {}));
+
 /**
  * Converts TypeDoc types into SKY UX docs-tools types, to be supplied to the various definitions components.
  */
@@ -2311,7 +2343,15 @@ class SkyDocsTypeDocAdapterService {
             return [];
         }
         const definitions = entry.children
-            .filter((child) => child.kindString === 'Property' || child.kindString === 'Accessor')
+            .filter((child) => 
+        // We only want properties (both with or without a getter/setter)
+        child.kind === TypeDocKind.Property ||
+            child.kind === TypeDocKind.Accessor)
+            .filter((child) => 
+        // We only want accessors that don't have a setter if they are not inputs
+        child.kind !== TypeDocKind.Accessor ||
+            child.setSignature ||
+            this.getDecorator(child)?.name !== 'Input')
             .map((child) => {
             let definition = {
                 isOptional: true,
@@ -2320,19 +2360,22 @@ class SkyDocsTypeDocAdapterService {
             };
             let defaultValue;
             /* Ensure we are properly capturing definitions which use a getter/setter. Final check is a sanity check */
-            if (child.kindString === 'Accessor' &&
-                !child.comment?.shortText &&
-                (child.setSignature?.length > 0 || child.getSignature.length > 0)) {
+            if (child.kind === TypeDocKind.Accessor &&
+                !child.comment?.summary
+                    ?.map((item) => item.text)
+                    .join('')
+                    .trim() &&
+                (child.setSignature || child.getSignature)) {
                 const mainTags = this.getCommentTags(child.comment);
                 this.applyCommentTagValues(definition, mainTags);
-                if (child.getSignature?.length > 0) {
-                    const getTags = this.getCommentTags(child.getSignature[0].comment);
+                if (child.getSignature) {
+                    const getTags = this.getCommentTags(child.getSignature.comment);
                     definition.isOptional = !getTags.extras.required;
                     this.applyCommentTagValues(definition, getTags);
                     defaultValue = this.getDefaultValue(child, getTags);
                 }
-                if (child.setSignature?.length > 0) {
-                    const setTags = this.getCommentTags(child.setSignature[0].comment);
+                if (child.setSignature) {
+                    const setTags = this.getCommentTags(child.setSignature.comment);
                     this.applyCommentTagValues(definition, setTags);
                     definition.isOptional =
                         definition.isOptional && !setTags.extras.required;
@@ -2345,8 +2388,11 @@ class SkyDocsTypeDocAdapterService {
             }
             else {
                 let tags;
-                if (child.kindString === 'Property' &&
-                    !child.comment?.shortText &&
+                if (child.kind === TypeDocKind.Property &&
+                    !child.comment?.summary
+                        ?.map((item) => item.text)
+                        .join('')
+                        .trim() &&
                     child.type.declaration?.signatures?.length > 0 &&
                     child.type.declaration.signatures[0].comment) {
                     tags = this.getCommentTags(child.type.declaration.signatures[0].comment);
@@ -2367,9 +2413,9 @@ class SkyDocsTypeDocAdapterService {
                 definition.decorator = decorator;
             }
             if (!definition.description) {
-                const constructor = entry.children.find((child) => child.kindString === 'Constructor');
+                const constructor = entry.children.find((child) => child.kind === TypeDocKind.Constructor);
                 if (constructor) {
-                    const signature = constructor.signatures.find((signature) => signature.kindString === 'Constructor signature');
+                    const signature = constructor.signatures.find((signature) => signature.kind === TypeDocKind.ConstructorSignature);
                     /* Sanity check */
                     /* istanbul ignore else */
                     if (signature) {
@@ -2390,7 +2436,7 @@ class SkyDocsTypeDocAdapterService {
             return [];
         }
         const methods = entry.children
-            .filter((child) => child.kindString === 'Method' && /^ng/.test(child.name) === false)
+            .filter((child) => child.kind === TypeDocKind.Method && /^ng/.test(child.name) === false)
             .map((child) => {
             const definition = {
                 name: this.getPropertyName(child),
@@ -2416,9 +2462,13 @@ class SkyDocsTypeDocAdapterService {
         }
         const definitions = entry.children?.map((child) => {
             let tags;
-            if (child.kindString === 'Method' && child.signatures.length > 0) {
+            if (child.kind === TypeDocKind.Method && child.signatures.length > 0) {
                 tags = this.getCommentTags(child.signatures[0].comment);
             }
+            else if (child.type.type === 'reflection' &&
+                child.type?.declaration?.signatures?.length > 0) {
+                tags = this.getCommentTags(child.type.declaration.signatures[0].comment);
+            }
             else {
                 tags = this.getCommentTags(child.comment);
             }
@@ -2462,14 +2512,14 @@ class SkyDocsTypeDocAdapterService {
     }
     getTypeDefinition(child) {
         let definition;
-        const kindString = child.kindString;
-        switch (kindString) {
-            case 'Accessor':
+        const kind = child.kind;
+        switch (kind) {
+            case TypeDocKind.Accessor:
                 if (child.setSignature) {
-                    return this.getTypeDefinition(child.setSignature[0].parameters[0]);
+                    return this.getTypeDefinition(child.setSignature.parameters[0]);
                 }
-                return this.getTypeDefinition(child.getSignature[0]);
-            case 'Method':
+                return this.getTypeDefinition(child.getSignature);
+            case TypeDocKind.Method:
                 definition = {
                     callSignature: this.getCallSignatureDefinition(child.signatures[0], this.getCommentTags(child.comment)),
                     name: child.signatures[0].name,
@@ -2599,38 +2649,58 @@ class SkyDocsTypeDocAdapterService {
         let parameters;
         const extras = {};
         if (comment) {
-            if (comment.tags) {
-                comment.tags.forEach((tag) => {
+            if (comment.blockTags) {
+                comment.blockTags.forEach((tag) => {
                     switch (tag.tag) {
-                        case 'deprecated':
-                            deprecationWarning = tag.text.trim();
+                        case '@deprecated':
+                            deprecationWarning = tag.content
+                                .map((item) => item.text)
+                                .join('')
+                                .trim();
                             break;
-                        case 'default':
-                        case 'defaultValue':
-                            defaultValue = tag.text.trim();
+                        case '@default':
+                        case '@defaultValue':
+                            defaultValue = tag.content
+                                .map((item) => item.text)
+                                .join('')
+                                .trim();
                             break;
-                        case 'example':
-                            codeExample = tag.text.trim().split('```')[1].trim();
+                        case '@example':
+                            codeExample = tag.content
+                                .map((item) => item.text)
+                                .join('')
+                                .trim()
+                                .split('```')[1]
+                                .trim();
                             const language = codeExample.split('\n')[0];
                             if (language === 'markup' || language === 'typescript') {
                                 codeExample = codeExample.slice(language.length).trim();
                                 codeExampleLanguage = language;
                             }
                             break;
-                        case 'param':
+                        case '@param':
                             parameters = parameters || [];
                             parameters.push({
                                 name: tag.param,
-                                description: tag.text.trim(),
+                                description: tag.content
+                                    .map((item) => item.text)
+                                    .join('')
+                                    .trim(),
                             });
                             break;
+                        case '@required':
+                            extras['required'] = true;
+                            break;
+                        /* istanbul ignore next */
                         default:
-                            extras[tag.tag] = tag.text;
                             break;
                     }
                 });
             }
-            description = (comment.shortText || comment.text || '').trim();
+            description = comment.summary
+                ?.map((item) => item.text)
+                .join('')
+                .trim();
         }
         return {
             codeExample,
@@ -2769,8 +2839,8 @@ class SkyDocsTypeDefinitionsService {
                 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;
+                const decorator = item.decorators && item.decorators[0]?.name;
+                const kind = item.kind;
                 switch (decorator) {
                     case 'Component':
                         types.components.push(this.adapter.toDirectiveDefinition(item));
@@ -2789,17 +2859,17 @@ class SkyDocsTypeDefinitionsService {
                         break;
                     default:
                         /*tslint:disable-next-line:switch-default*/
-                        switch (kindString) {
-                            case 'Class':
+                        switch (kind) {
+                            case TypeDocKind.Class:
                                 types.classes.push(this.adapter.toClassDefinition(item));
                                 break;
-                            case 'Interface':
+                            case TypeDocKind.Interface:
                                 types.interfaces.push(this.adapter.toInterfaceDefinition(item));
                                 break;
-                            case 'Enumeration':
+                            case TypeDocKind.Enum:
                                 types.enumerations.push(this.adapter.toEnumerationDefinition(item));
                                 break;
-                            case 'Type alias':
+                            case TypeDocKind.TypeAlias:
                                 types.typeAliases.push(this.adapter.toTypeAliasDefinition(item));
                                 break;
                         }