@workday/canvas-kit-docs 9.0.0-alpha.368-next.6 → 9.0.0-alpha.382-next.2

package/dist/es6/docgen/plugins/modelParser.js

@@ -1,20 +1,9 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import { createParserPlugin, getValueDeclaration, defaultJSDoc, getSymbolFromNode, getFullJsDocComment, } from '../docParser';
 import t from '../traverse';
 function capitalize(string) {
     return string[0].toUpperCase() + string.substring(1);
 }
-export var modelParser = createParserPlugin(function (node, parser) {
+export const modelParser = createParserPlugin((node, parser) => {
     var _a;
     /**
      * Replace submenus with symbols rather than types.
@@ -52,17 +41,17 @@ export var modelParser = createParserPlugin(function (node, parser) {
      * ```
      */
     if (t.isShorthandPropertyAssignment(node)) {
-        var checker = parser.checker;
-        var symbol = getSymbolFromNode(checker, node);
-        var declaration = getValueDeclaration(symbol);
-        var name_1 = (symbol === null || symbol === void 0 ? void 0 : symbol.name) || t.isIdentifier(node.name) ? node.name.text : '';
+        const { checker } = parser;
+        const symbol = getSymbolFromNode(checker, node);
+        const declaration = getValueDeclaration(symbol);
+        const name = (symbol === null || symbol === void 0 ? void 0 : symbol.name) || t.isIdentifier(node.name) ? node.name.text : '';
         if (declaration && declaration.getSourceFile()) {
             // ShorthandPropertyAssignment doesn't give the original variable declaration
-            var originalDeclaration = t(declaration.getSourceFile())
+            const originalDeclaration = t(declaration.getSourceFile())
                 .find('VariableDeclaration')
-                .map(function (node) {
+                .map(node => {
                 if (t.isIdentifier(node.name) &&
-                    node.name.text === name_1 &&
+                    node.name.text === name &&
                     node.initializer &&
                     t.isCallExpression(node.initializer) &&
                     t.isIdentifier(node.initializer.expression) &&
@@ -74,10 +63,17 @@ export var modelParser = createParserPlugin(function (node, parser) {
                 }
                 return;
             })
-                .filter(function (v) { return !!v; })[0];
+                .filter(v => !!v)[0];
             if (originalDeclaration) {
-                var jsDoc = symbol ? getFullJsDocComment(checker, symbol) : defaultJSDoc;
-                return __assign({ kind: 'property', name: name_1, defaultValue: undefined, type: originalDeclaration, required: false }, jsDoc);
+                const jsDoc = symbol ? getFullJsDocComment(checker, symbol) : defaultJSDoc;
+                return {
+                    kind: 'property',
+                    name,
+                    defaultValue: undefined,
+                    type: originalDeclaration,
+                    required: false,
+                    ...jsDoc,
+                };
             }
         }
     }
@@ -109,9 +105,9 @@ export var modelParser = createParserPlugin(function (node, parser) {
      * ```
      */
     if (t.isTypeReference(node)) {
-        var firstArgument = (_a = node.typeArguments) === null || _a === void 0 ? void 0 : _a[0];
+        const firstArgument = (_a = node.typeArguments) === null || _a === void 0 ? void 0 : _a[0];
         if (firstArgument && t.isTypeQuery(firstArgument) && t.isIdentifier(firstArgument.exprName)) {
-            var modelName = firstArgument.exprName.text;
+            const modelName = firstArgument.exprName.text;
             return { kind: 'symbol', name: modelName };
         }
     }
@@ -124,12 +120,19 @@ export var modelParser = createParserPlugin(function (node, parser) {
         t.isIdentifier(node.initializer.type.exprName.right) &&
         // TConfig is special from models
         node.initializer.type.exprName.right.text === 'TConfig') {
-        var symbol = getSymbolFromNode(parser.checker, node);
-        var jsDoc = (symbol && getFullJsDocComment(parser.checker, symbol)) || defaultJSDoc;
-        return __assign({ kind: 'property', name: node.name.text, defaultValue: parser.getValueFromNode(node.initializer.expression), required: false, type: {
+        const symbol = getSymbolFromNode(parser.checker, node);
+        const jsDoc = (symbol && getFullJsDocComment(parser.checker, symbol)) || defaultJSDoc;
+        return {
+            kind: 'property',
+            name: node.name.text,
+            defaultValue: parser.getValueFromNode(node.initializer.expression),
+            required: false,
+            type: {
                 kind: 'symbol',
                 name: node.initializer.type.exprName.left.text.replace('use', '') + 'Config',
-            } }, jsDoc);
+            },
+            ...jsDoc,
+        };
     }
     /**
      * This parsing matcher handles models created using `createModelHook` and adds additional symbols
@@ -173,109 +176,166 @@ export var modelParser = createParserPlugin(function (node, parser) {
         t.isIdentifier(node.initializer.expression.expression) &&
         node.initializer.expression.expression.text === 'createModelHook') {
         // we have a model
-        var modelName_1 = node.name.text.replace('use', '');
+        const modelName = node.name.text.replace('use', '');
         // get the symbol for the model hook
-        var symbol = getSymbolFromNode(parser.checker, node);
-        var jsDoc = symbol ? getFullJsDocComment(parser.checker, symbol) : defaultJSDoc;
-        var options = node.initializer.expression.arguments[0];
-        var optionsType = parser.checker.getTypeAtLocation(options);
-        var configProps = optionsType.getProperties().reduce(function (result, symbol) {
+        const symbol = getSymbolFromNode(parser.checker, node);
+        const jsDoc = symbol ? getFullJsDocComment(parser.checker, symbol) : defaultJSDoc;
+        const options = node.initializer.expression.arguments[0];
+        const optionsType = parser.checker.getTypeAtLocation(options);
+        const configProps = optionsType.getProperties().reduce((result, symbol) => {
             if (['defaultConfig', 'requiredConfig'].includes(symbol.getName())) {
                 // The declaration of the config
-                var declaration = getValueDeclaration(symbol);
+                const declaration = getValueDeclaration(symbol);
                 if (declaration) {
                     result[symbol.getName()] = parser.checker
                         .getTypeAtLocation(declaration)
                         .getProperties()
-                        .map(function (p) {
+                        .map(p => {
                         // Each property of the config
-                        var prop = getValueDeclaration(p);
-                        return __assign(__assign({}, parser.getValueFromNode(prop)), { required: symbol.getName() === 'requiredConfig' });
+                        const prop = getValueDeclaration(p);
+                        return {
+                            ...parser.getValueFromNode(prop),
+                            required: symbol.getName() === 'requiredConfig',
+                        };
                     });
                 }
             }
             return result;
         }, {});
-        var modelProps_1 = {};
-        var returnProps_1 = {};
-        var type = parser.checker.getTypeAtLocation(node.initializer.arguments[0]);
-        type.getCallSignatures().forEach(function (signature) {
+        const modelProps = {};
+        const returnProps = {};
+        const type = parser.checker.getTypeAtLocation(node.initializer.arguments[0]);
+        type.getCallSignatures().forEach(signature => {
             signature
                 .getReturnType()
                 .getProperties()
-                .forEach(function (property) {
-                var declaration = getValueDeclaration(property);
+                .forEach(property => {
+                const declaration = getValueDeclaration(property);
                 if (declaration) {
                     if (['state', 'events'].includes(property.getName())) {
-                        modelProps_1[property.getName()] = parser.checker
+                        modelProps[property.getName()] = parser.checker
                             .getTypeAtLocation(declaration)
                             .getProperties()
-                            .map(function (prop) {
-                            return __assign(__assign({}, parser.getValueFromNode(getValueDeclaration(prop))), { defaultValue: undefined });
+                            .map(prop => {
+                            return {
+                                ...parser.getValueFromNode(getValueDeclaration(prop)),
+                                defaultValue: undefined, // no defaults for state/events
+                            };
                         });
                     }
                     else {
-                        returnProps_1[property.getName()] = parser.getValueFromNode(declaration);
+                        returnProps[property.getName()] = parser.getValueFromNode(declaration);
                     }
                 }
             });
         });
-        var state = modelProps_1.state, events = modelProps_1.events;
-        var fileName_1 = node.getSourceFile().fileName;
+        const { state, events } = modelProps;
+        const fileName = node.getSourceFile().fileName;
         // Add special symbols
         // Model
-        parser.symbols.push(__assign(__assign({ name: modelName_1, fileName: fileName_1 }, jsDoc), { type: {
+        parser.symbols.push({
+            name: modelName,
+            fileName,
+            ...jsDoc,
+            type: {
                 kind: 'model',
-                state: state,
-                events: events,
-                modelProperties: Object.keys(returnProps_1).map(function (p) { return returnProps_1[p]; }),
-            } }));
+                state,
+                events,
+                modelProperties: Object.keys(returnProps).map(p => returnProps[p]),
+            },
+        });
         // Model config
-        var eventConfig = (events || []).reduce(function (result, event) {
-            var _a, _b;
-            var type = event.type;
+        const eventConfig = (events || []).reduce((result, event) => {
+            const type = event.type;
             // callback of the event
-            result.push(__assign(__assign({}, event), { defaultValue: undefined, name: "on" + capitalize(event.name), required: false, type: __assign(__assign({}, type), { parameters: (_a = [
-                        __assign(__assign({}, defaultJSDoc), { kind: 'parameter', name: 'state', required: true, type: {
+            result.push({
+                ...event,
+                defaultValue: undefined,
+                name: `on${capitalize(event.name)}`,
+                required: false,
+                type: {
+                    ...type,
+                    parameters: [
+                        {
+                            ...defaultJSDoc,
+                            kind: 'parameter',
+                            name: 'state',
+                            required: true,
+                            type: {
                                 kind: 'symbol',
-                                name: modelName_1 + "State",
-                                fileName: fileName_1,
-                            } }),
-                    ]).concat.apply(_a, type.parameters), returnType: {
+                                name: `${modelName}State`,
+                                fileName,
+                            },
+                        },
+                    ].concat(...type.parameters),
+                    returnType: {
                         kind: 'primitive',
                         value: 'void',
-                    } }) }));
+                    },
+                },
+            });
             // guard of the event
-            result.push(__assign(__assign({}, event), { defaultValue: undefined, name: "should" + capitalize(event.name), required: false, type: __assign(__assign({}, type), { parameters: (_b = [
-                        __assign(__assign({}, defaultJSDoc), { kind: 'parameter', name: 'state', required: true, type: {
+            result.push({
+                ...event,
+                defaultValue: undefined,
+                name: `should${capitalize(event.name)}`,
+                required: false,
+                type: {
+                    ...type,
+                    parameters: [
+                        {
+                            ...defaultJSDoc,
+                            kind: 'parameter',
+                            name: 'state',
+                            required: true,
+                            type: {
                                 kind: 'symbol',
-                                name: modelName_1 + "State",
-                                fileName: fileName_1,
-                            } }),
-                    ]).concat.apply(_b, type.parameters), returnType: {
+                                name: `${modelName}State`,
+                                fileName,
+                            },
+                        },
+                    ].concat(...type.parameters),
+                    returnType: {
                         kind: 'primitive',
                         value: 'boolean',
-                    } }) }));
+                    },
+                },
+            });
             return result;
         }, []);
-        parser.symbols.push(__assign(__assign({ name: modelName_1 + "Config", fileName: fileName_1 }, jsDoc), { type: {
+        parser.symbols.push({
+            name: `${modelName}Config`,
+            fileName,
+            ...jsDoc,
+            type: {
                 kind: 'object',
                 properties: (configProps['defaultConfig'] || []).concat(configProps['requiredConfig'], eventConfig),
-            } }));
+            },
+        });
         // Model State
-        parser.symbols.push(__assign(__assign({ name: modelName_1 + "State", fileName: fileName_1 }, defaultJSDoc), { type: {
+        parser.symbols.push({
+            name: `${modelName}State`,
+            fileName,
+            ...defaultJSDoc,
+            type: {
                 kind: 'object',
                 properties: state,
-            } }));
+            },
+        });
         // Model Events
-        parser.symbols.push(__assign(__assign({ name: modelName_1 + "Events", fileName: fileName_1 }, defaultJSDoc), { type: {
+        parser.symbols.push({
+            name: `${modelName}Events`,
+            fileName,
+            ...defaultJSDoc,
+            type: {
                 kind: 'object',
                 properties: events,
-            } }));
+            },
+        });
         // Model Hook
         return {
             kind: 'modelHook',
-            name: "use" + modelName_1,
+            name: `use${modelName}`,
             defaultConfig: configProps['defaultConfig'] || [],
             requiredConfig: configProps['requiredConfig'] || [],
         };