@workday/canvas-kit-codemod 6.8.9 → 6.9.0-next.5

package/dist/es6/v5/recategorizeButtons.js

@@ -146,8 +146,8 @@ export default function transformer(file, api, options) {
     }
     else {
         buttonImports.forEach(function (_a) {
-            var node = _a.node;
             var _b;
+            var node = _a.node;
             var specifiersToRemove = [
                 'DropdownButton',
                 'TextButton',

package/dist/es6/v7/compoundActionBar.d.ts

@@ -0,0 +1,3 @@
+import { API, FileInfo, Options } from 'jscodeshift';
+export default function transformer(file: FileInfo, api: API, options: Options): string;
+//# sourceMappingURL=compoundActionBar.d.ts.map

package/dist/es6/v7/compoundActionBar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compoundActionBar.d.ts","sourceRoot":"","sources":["../../../lib/v7/compoundActionBar.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAyC,MAAM,aAAa,CAAC;AAM3F,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UA0H7E"}

package/dist/es6/v7/compoundActionBar.js

@@ -0,0 +1,91 @@
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
+import { getImportRenameMap } from './utils/getImportRenameMap';
+import { hasImportSpecifiers } from '../v6/utils';
+var actionBarPackage = '@workday/canvas-kit-react/action-bar';
+export default function transformer(file, api, options) {
+    var j = api.jscodeshift;
+    var root = j(file.source);
+    if (!hasImportSpecifiers(api, root, actionBarPackage, ['ActionBar'])) {
+        return file.source;
+    }
+    // Replace default import with named or renamed import
+    root.find(j.ImportDefaultSpecifier).forEach(function (nodePath) {
+        var _a;
+        var parent = nodePath.parent;
+        var importSource = String(parent.node.source.value);
+        var localName = (_a = nodePath.value.local) === null || _a === void 0 ? void 0 : _a.name;
+        if (actionBarPackage === importSource && localName) {
+            nodePath.replace(j.importSpecifier(j.identifier('ActionBar'), j.identifier(localName)));
+        }
+    });
+    var _a = getImportRenameMap(j, root, '@workday/canvas-kit-react/action-bar'), importMap = _a.importMap, styledMap = _a.styledMap;
+    root
+        .find(j.JSXElement, function (value) {
+        return value.openingElement.name.type === 'JSXIdentifier' &&
+            (value.openingElement.name.name === importMap.ActionBar ||
+                value.openingElement.name.name === styledMap.ActionBar);
+    })
+        .forEach(function (nodePath) {
+        (nodePath.value.children || []).forEach(function (child, index) {
+            if (child.type === 'JSXElement') {
+                // bail early if we find a `ActionBar.List` as a child
+                if (child.openingElement.name.type === 'JSXMemberExpression' &&
+                    child.openingElement.name.object.type === 'JSXIdentifier' &&
+                    child.openingElement.name.object.name === 'ActionBar' &&
+                    child.openingElement.name.property.type === 'JSXIdentifier' &&
+                    child.openingElement.name.property.name === 'List') {
+                    return;
+                }
+                // Transform Primary and Secondary button to ActionBar.Item
+                if (child.openingElement.name.type === 'JSXIdentifier') {
+                    var buttonAttrs = child.openingElement.attributes || [];
+                    var ActionItemJSX = j.jsxMemberExpression(j.jsxIdentifier(importMap.ActionBar), j.jsxIdentifier('Item'));
+                    if (nodePath.value.children &&
+                        ['PrimaryButton', 'SecondaryButton'].includes(child.openingElement.name.name)) {
+                        // Add isPrimary attribute to primary Action Item
+                        var elementAttrs = child.openingElement.name.name === 'PrimaryButton'
+                            ? __spreadArrays(buttonAttrs, [j.jsxAttribute(j.jsxIdentifier('isPrimary'))]) : buttonAttrs;
+                        nodePath.value.children[index] = j.jsxElement(j.jsxOpeningElement(ActionItemJSX, elementAttrs), j.jsxClosingElement(ActionItemJSX), child.children);
+                    }
+                }
+            }
+        });
+        var children = nodePath.value.children || [];
+        // Remove all attributes from ActionBar to replace them to ActionBar.List
+        var attributes = nodePath.value.openingElement.attributes;
+        if (attributes) {
+            nodePath.value.openingElement.attributes = attributes.filter(function (item) { return !(item.type === 'JSXAttribute' && item.name.type === 'JSXIdentifier'); });
+        }
+        // Create closing element for ActionBar without closing tag
+        if (nodePath.value.openingElement.selfClosing) {
+            nodePath.value.openingElement.selfClosing = false;
+            nodePath.value.closingElement = j.jsxClosingElement(nodePath.value.openingElement.name);
+        }
+        // Create ActionBar.List component
+        var ActionBarListJSX = j.jsxMemberExpression(j.jsxIdentifier(importMap.ActionBar), j.jsxIdentifier('List'));
+        var subComponentJSX = j.jsxElement(j.jsxOpeningElement(ActionBarListJSX, 
+        // All attributes except fixed should be passed
+        attributes === null || 
+        // All attributes except fixed should be passed
+        attributes === void 0 ? void 0 : 
+        // All attributes except fixed should be passed
+        attributes.filter(function (attr) { return !(attr.type === 'JSXAttribute' && attr.name.name === 'fixed'); })), j.jsxClosingElement(ActionBarListJSX), children);
+        // Keep space for code structure
+        var textLiteralStart = children.find(function (child) { return child.type === 'JSXText'; });
+        var textLiteralEnd = children
+            .slice()
+            .reverse()
+            .find(function (child) { return child.type === 'JSXText'; });
+        nodePath.value.children =
+            textLiteralStart && textLiteralEnd
+                ? [textLiteralStart, subComponentJSX, textLiteralEnd]
+                : [subComponentJSX];
+    });
+    return root.toSource();
+}

package/dist/es6/v7/compoundBanner.d.ts

@@ -0,0 +1,3 @@
+import { API, FileInfo, Options } from 'jscodeshift';
+export default function transformer(file: FileInfo, api: API, options: Options): string;
+//# sourceMappingURL=compoundBanner.d.ts.map

package/dist/es6/v7/compoundBanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compoundBanner.d.ts","sourceRoot":"","sources":["../../../lib/v7/compoundBanner.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EACH,QAAQ,EACR,OAAO,EAUR,MAAM,aAAa,CAAC;AAQrB,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UAuM7E"}

package/dist/es6/v7/compoundBanner.js

@@ -0,0 +1,133 @@
+import { getImportRenameMap } from './utils/getImportRenameMap';
+function filterDefined(input) {
+    return !!input;
+}
+export default function transformer(file, api, options) {
+    var j = api.jscodeshift;
+    var root = j(file.source);
+    var _a = getImportRenameMap(j, root, '@workday/canvas-kit-react/banner'), containsCanvasImports = _a.containsCanvasImports, importMap = _a.importMap, styledMap = _a.styledMap;
+    if (!containsCanvasImports) {
+        return file.source;
+    }
+    root
+        .find(j.JSXElement, function (value) {
+        return value.openingElement.name.type === 'JSXIdentifier' &&
+            (value.openingElement.name.name === importMap.Banner ||
+                value.openingElement.name.name === styledMap.Banner);
+    })
+        .forEach(function (nodePath) {
+        var _a, _b;
+        // bail early if we find a `Banner.Label` as a child
+        for (var _i = 0, _c = nodePath.value.children || []; _i < _c.length; _i++) {
+            var child = _c[_i];
+            if (child.type === 'JSXElement' &&
+                child.openingElement.name.type === 'JSXMemberExpression' &&
+                child.openingElement.name.object.type === 'JSXIdentifier' &&
+                child.openingElement.name.object.name === 'Banner' &&
+                child.openingElement.name.property.type === 'JSXIdentifier' &&
+                child.openingElement.name.property.name === 'Label') {
+                return;
+            }
+        }
+        var findAttribute = function (name) { return function (item) {
+            if (item.type === 'JSXAttribute' &&
+                item.name.type === 'JSXIdentifier' &&
+                item.name.name === name) {
+                return true;
+            }
+            return false;
+        }; };
+        var attributes = nodePath.value.openingElement.attributes;
+        if (attributes) {
+            var label = attributes.find(findAttribute('label'));
+            var actionText = attributes.find(findAttribute('actionText'));
+            var errorIndex_1 = attributes.findIndex(findAttribute('error'));
+            var variantIndex_1 = attributes.findIndex(findAttribute('variant'));
+            if (errorIndex_1 >= 0 && ((_a = nodePath.value.openingElement.attributes) === null || _a === void 0 ? void 0 : _a[errorIndex_1])) {
+                var errorExpression = nodePath.value.openingElement.attributes[errorIndex_1].value.expression;
+                var getNameToBoolean = function (name) {
+                    return name === 'Error' ? j.booleanLiteral(true) : j.booleanLiteral(false);
+                };
+                var setHasError = function (hasErrorValue) {
+                    if (nodePath.value.openingElement.attributes) {
+                        nodePath.value.openingElement.attributes[errorIndex_1] = j.jsxAttribute(j.jsxIdentifier('hasError'), j.jsxExpressionContainer(hasErrorValue));
+                    }
+                };
+                if (errorExpression.property) {
+                    var previousExpression = errorExpression;
+                    var newValue = getNameToBoolean(previousExpression.property.name);
+                    setHasError(newValue);
+                }
+                if (errorExpression.test) {
+                    var previousExpression = errorExpression;
+                    var newValue = j.conditionalExpression(previousExpression.test, getNameToBoolean(previousExpression.consequent.property.name), getNameToBoolean(previousExpression.alternate.property.name));
+                    setHasError(newValue);
+                }
+            }
+            if (variantIndex_1 >= 0 && ((_b = nodePath.value.openingElement.attributes) === null || _b === void 0 ? void 0 : _b[variantIndex_1])) {
+                var stickyExpression = nodePath.value.openingElement.attributes[variantIndex_1].value.expression;
+                var getNameToBoolean = function (name) {
+                    return name === 'Sticky' ? j.booleanLiteral(true) : j.booleanLiteral(false);
+                };
+                var setIsSticky = function (hasStickyValue) {
+                    if (nodePath.value.openingElement.attributes) {
+                        nodePath.value.openingElement.attributes[variantIndex_1] = j.jsxAttribute(j.jsxIdentifier('isSticky'), j.jsxExpressionContainer(hasStickyValue));
+                    }
+                };
+                if (stickyExpression.property) {
+                    var previousExpression = stickyExpression;
+                    var newValue = getNameToBoolean(previousExpression.property.name);
+                    setIsSticky(newValue);
+                }
+                if (stickyExpression.test) {
+                    var previousExpression = stickyExpression;
+                    var newValue = j.conditionalExpression(previousExpression.test, getNameToBoolean(previousExpression.consequent.property.name), getNameToBoolean(previousExpression.alternate.property.name));
+                    setIsSticky(newValue);
+                }
+            }
+            // remove these attributes from the list - we'll add them as sub components
+            nodePath.value.openingElement.attributes = attributes.filter(function (item) {
+                if (item.type === 'JSXAttribute' &&
+                    item.name.type === 'JSXIdentifier' &&
+                    ['label', 'actionText'].includes(item.name.name)) {
+                    return false;
+                }
+                return true;
+            });
+            var BannerIconJSX = j.jsxMemberExpression(j.jsxIdentifier(importMap.Banner), j.jsxIdentifier('Icon'));
+            var BannerLabelJSX = j.jsxMemberExpression(j.jsxIdentifier(importMap.Banner), j.jsxIdentifier('Label'));
+            var BannerActionTextJSX = j.jsxMemberExpression(j.jsxIdentifier(importMap.Banner), j.jsxIdentifier('ActionText'));
+            var convertAttributeToChildren = function (input) {
+                var _a;
+                switch ((_a = input.value) === null || _a === void 0 ? void 0 : _a.type) {
+                    case 'JSXExpressionContainer':
+                        // unwrap JSXElements
+                        if (input.value.expression.type === 'JSXElement') {
+                            return [input.value.expression];
+                        }
+                        return [input.value];
+                    default:
+                        return [input.value];
+                }
+            };
+            var createSelfClosingTag = function (Tag) {
+                var OpeningTag = j.jsxOpeningElement(Tag);
+                OpeningTag.selfClosing = true;
+                return j.jsxElement(OpeningTag);
+            };
+            nodePath.value.openingElement.selfClosing = false;
+            // Add subcomponents back as children
+            nodePath.value.children = [
+                createSelfClosingTag(BannerIconJSX),
+                !!label
+                    ? j.jsxElement(j.jsxOpeningElement(BannerLabelJSX), j.jsxClosingElement(BannerLabelJSX), convertAttributeToChildren(label))
+                    : createSelfClosingTag(BannerLabelJSX),
+                !!actionText
+                    ? j.jsxElement(j.jsxOpeningElement(BannerActionTextJSX), j.jsxClosingElement(BannerActionTextJSX), convertAttributeToChildren(actionText))
+                    : createSelfClosingTag(BannerActionTextJSX),
+            ].filter(filterDefined);
+            nodePath.value.closingElement = j.jsxClosingElement(nodePath.value.openingElement.name);
+        }
+    });
+    return root.toSource();
+}

package/dist/es6/v7/index.d.ts

@@ -0,0 +1,4 @@
+import { Transform } from 'jscodeshift';
+declare const transform: Transform;
+export default transform;
+//# sourceMappingURL=index.d.ts.map

package/dist/es6/v7/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../lib/v7/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AActC,QAAA,MAAM,SAAS,EAAE,SAiBhB,CAAC;AACF,eAAe,SAAS,CAAC"}

package/dist/es6/v7/index.js

@@ -0,0 +1,40 @@
+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 compoundActionBar from './compoundActionBar';
+import compoundBanner from './compoundBanner';
+import removePropFromPopper from './removePropFromPopper';
+import renameIconRef from './renameIconRef';
+import renameLayoutImports from './renameLayoutImports';
+import updateSegmentedControl from './updateSegmentedControl';
+import renameIconPosition from './renameIconPosition';
+import recategorizeIconButtons from './recategorizeIconButtons';
+import updateModelSignatures from './updateModelSignatures';
+import updateTabs from './updateTabs';
+import updateDisclosureShowHide from './updateDisclosureShowHide';
+var transform = function (file, api, options) {
+    // These will run in order. If your transform depends on others, place yours after dependent transforms
+    var fixes = [
+        compoundActionBar,
+        compoundBanner,
+        recategorizeIconButtons,
+        renameIconRef,
+        removePropFromPopper,
+        renameIconPosition,
+        renameLayoutImports,
+        updateSegmentedControl,
+        updateModelSignatures,
+        updateTabs,
+        updateDisclosureShowHide,
+    ];
+    return fixes.reduce(function (source, fix) { return fix(__assign(__assign({}, file), { source: source }), api, options); }, file.source);
+};
+export default transform;

package/dist/es6/v7/recategorizeIconButtons.d.ts

@@ -0,0 +1,3 @@
+import { API, FileInfo, Options } from 'jscodeshift';
+export default function transformer(file: FileInfo, api: API, options: Options): string;
+//# sourceMappingURL=recategorizeIconButtons.d.ts.map

package/dist/es6/v7/recategorizeIconButtons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recategorizeIconButtons.d.ts","sourceRoot":"","sources":["../../../lib/v7/recategorizeIconButtons.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EACH,QAAQ,EACR,OAAO,EAMR,MAAM,aAAa,CAAC;AAcrB,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UA8K7E"}

package/dist/es6/v7/recategorizeIconButtons.js

@@ -0,0 +1,148 @@
+import { getImportRenameMap } from './utils/getImportRenameMap';
+import chalk from 'chalk';
+var updateJSXTag = function (nodePath, newTag) {
+    var componentName = nodePath.value.openingElement.name.name;
+    if (componentName === 'IconButton') {
+        nodePath.value.openingElement.name.name = newTag;
+        if (nodePath.value.closingElement) {
+            nodePath.value.closingElement.name.name = newTag;
+        }
+    }
+};
+export default function transformer(file, api, options) {
+    var j = api.jscodeshift;
+    var root = j(file.source);
+    var requiredImportSpecifiers = [];
+    /**
+     * 1. Find button imports
+     */
+    var _a = getImportRenameMap(j, root, '@workday/canvas-kit-react/button'), containsCanvasImports = _a.containsCanvasImports, importMap = _a.importMap, styledMap = _a.styledMap;
+    if (!containsCanvasImports) {
+        return file.source;
+    }
+    var buttonType = 'TertiaryButton'; //default button if no variant is specified
+    // Button Mapping
+    // circle -> tertiary
+    // circle-filled -> secondary
+    // inverse -> tertiary inverse
+    // inverse-filled -> secondary inverse
+    // plain/square -> not supported
+    // square-filled -> not supported
+    /**
+     * 2. Find `IconButton`
+     *  - If it has no variant, it means it's "circle" which is the default
+     *    - Swap to `TertiaryButton`
+     *    - Add `TertiaryButton` import if it doesn't exist.
+     *  - If not
+     *    - check the variant of the IconButton
+     *    - Swap it out for the appropriate mapping
+     */
+    root
+        .find(j.JSXElement, function (value) {
+        return value.openingElement.name.type === 'JSXIdentifier' &&
+            (value.openingElement.name.name === importMap.IconButton ||
+                value.openingElement.name.name === styledMap.IconButton);
+    })
+        .forEach(function (nodePath) {
+        var _a;
+        var attrs = nodePath.value.openingElement.attributes;
+        var variantProp = attrs === null || attrs === void 0 ? void 0 : attrs.find(function (attr) { return attr.type === 'JSXAttribute' && attr.name.name === 'variant'; });
+        // Default IconButton variant is `circle`
+        if (variantProp) {
+            var valueBody = variantProp.value;
+            if ((valueBody === null || valueBody === void 0 ? void 0 : valueBody.type) === 'JSXExpressionContainer' &&
+                valueBody.expression.type === 'StringLiteral') {
+                variantProp.value = valueBody.expression;
+            }
+            var variantPropValue = variantProp.value.value;
+            if (variantPropValue) {
+                variantProp.value.value = variantPropValue.replace('Filled', '');
+                buttonType = /filled/gi.test(variantPropValue) ? 'SecondaryButton' : 'TertiaryButton';
+                if (!variantPropValue.includes('inverse')) {
+                    (_a = nodePath.value.openingElement.attributes) === null || _a === void 0 ? void 0 : _a.splice(attrs === null || attrs === void 0 ? void 0 : attrs.indexOf(variantProp), 1);
+                }
+            }
+            else {
+                console.warn(chalk.bold.red('** CANNOT UPDATE EXPRESSION FOR ICON BUTTON VARIANT. **') +
+                    '\nYou will need to manually update this file to fix this warning.' +
+                    '\nFile Name: ' +
+                    chalk.blue(file.path) +
+                    '\nConsult Upgrade Guide Section for v7: "Removal of Icon Button"');
+            }
+        }
+        updateJSXTag(nodePath, buttonType);
+        requiredImportSpecifiers.push(buttonType);
+    });
+    if (requiredImportSpecifiers.length === 0) {
+        return file.source;
+    }
+    // Find all instances of IconButton within a style function
+    // const StyledIconButton = styled(IconButton) gets renamed to
+    // const StyledIconButton = styled(CorrectButtonMapping)
+    root.find(j.VariableDeclarator).forEach(function (nodePath) {
+        var _a;
+        if (((_a = nodePath.value.init) === null || _a === void 0 ? void 0 : _a.type) === 'CallExpression' &&
+            nodePath.value.init.callee.type === 'CallExpression' &&
+            nodePath.value.init.callee.callee.type === 'Identifier' &&
+            nodePath.value.init.callee.callee.name === 'styled' &&
+            nodePath.value.init.callee.arguments[0].type === 'Identifier' &&
+            nodePath.value.init.callee.arguments[0].name === importMap.IconButton) {
+            nodePath.value.init.callee.arguments[0].name = buttonType;
+            requiredImportSpecifiers.push(buttonType);
+        }
+    });
+    /**
+     * Remove old imports: `IconButton`
+     * Add new required imports
+     */
+    var buttonImports = root.find(j.ImportDeclaration, {
+        source: {
+            value: function (value) {
+                return value === '@workday/canvas-kit-react' || value === '@workday/canvas-kit-react/button';
+            },
+        },
+    });
+    if (!buttonImports.length) {
+        // Add new specifiers to a new import
+        var allImports = root.find(j.ImportDeclaration);
+        var lastImport = allImports.at(allImports.length);
+        if (lastImport) {
+            lastImport.insertAfter(j.importDeclaration(requiredImportSpecifiers.map(function (specifier) { return j.importSpecifier(j.identifier(specifier)); }), j.stringLiteral('@workday/canvas-kit-react/button')));
+        }
+    }
+    else {
+        buttonImports.forEach(function (nodePath) {
+            var _a, _b, _c;
+            var node = nodePath.node;
+            var specifiersToRemove = ['IconButton'];
+            // Remove old specifiers
+            if (typeof node.source.value === 'string' &&
+                node.source.value.includes('@workday/canvas-kit-react')) {
+                (_a = node.specifiers) === null || _a === void 0 ? void 0 : _a.forEach(function (specifier) {
+                    var _a, _b;
+                    if (specifier.type === 'ImportSpecifier' &&
+                        specifiersToRemove.includes(specifier.imported.name)) {
+                        // delete specifier
+                        (_a = node.specifiers) === null || _a === void 0 ? void 0 : _a.splice((_b = node.specifiers) === null || _b === void 0 ? void 0 : _b.indexOf(specifier), 1);
+                    }
+                });
+            }
+            //  Add new specifiers to existing import
+            requiredImportSpecifiers.forEach(function (specifier) {
+                var _a, _b;
+                if (!((_a = node.specifiers) === null || _a === void 0 ? void 0 : _a.find(function (existing) { return existing.type === 'ImportSpecifier' && existing.imported.name === specifier; }))) {
+                    // Only add a specifier if it has not already been declared
+                    if (!importMap[buttonType]) {
+                        (_b = node.specifiers) === null || _b === void 0 ? void 0 : _b.push(j.importSpecifier(j.identifier(specifier)));
+                    }
+                }
+            });
+            console.log((_b = node.specifiers) === null || _b === void 0 ? void 0 : _b.length);
+            // if we removed all specifiers, remove the import
+            if (!((_c = node.specifiers) === null || _c === void 0 ? void 0 : _c.length)) {
+                nodePath.prune();
+            }
+        });
+    }
+    return root.toSource();
+}

package/dist/es6/v7/removePropFromPopper.d.ts

@@ -0,0 +1,3 @@
+import { API, FileInfo, Options } from 'jscodeshift';
+export default function transformer(file: FileInfo, api: API, options: Options): string;
+//# sourceMappingURL=removePropFromPopper.d.ts.map

package/dist/es6/v7/removePropFromPopper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"removePropFromPopper.d.ts","sourceRoot":"","sources":["../../../lib/v7/removePropFromPopper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAa,MAAM,aAAa,CAAC;AAM/D,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UAkC7E"}

package/dist/es6/v7/removePropFromPopper.js

@@ -0,0 +1,31 @@
+import { getImportRenameMap } from './utils/getImportRenameMap';
+import { hasImportSpecifiers } from '../v6/utils';
+var popupBarPackage = '@workday/canvas-kit-react/popup';
+export default function transformer(file, api, options) {
+    var j = api.jscodeshift;
+    var root = j(file.source);
+    if (!hasImportSpecifiers(api, root, popupBarPackage, ['Popper'])) {
+        return file.source;
+    }
+    var _a = getImportRenameMap(j, root, popupBarPackage), importMap = _a.importMap, styledMap = _a.styledMap;
+    root
+        .find(j.JSXElement, function (value) {
+        return value.openingElement.name.type === 'JSXIdentifier' &&
+            (value.openingElement.name.name === importMap.Popper ||
+                value.openingElement.name.name === styledMap.Popper);
+    })
+        .forEach(function (nodePath) {
+        var attributes = nodePath.value.openingElement.attributes;
+        // Remove containerElement prop from Popper component
+        if (attributes) {
+            nodePath.value.openingElement.attributes = attributes.filter(function (item) {
+                return item.type === 'JSXAttribute' &&
+                    item.name.type === 'JSXIdentifier' &&
+                    ['containerElement'].includes(item.name.name)
+                    ? false
+                    : true;
+            });
+        }
+    });
+    return root.toSource();
+}

package/dist/es6/v7/renameIconPosition.d.ts

@@ -0,0 +1,3 @@
+import { API, FileInfo, Options } from 'jscodeshift';
+export default function transformer(file: FileInfo, api: API, options: Options): string;
+//# sourceMappingURL=renameIconPosition.d.ts.map

package/dist/es6/v7/renameIconPosition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renameIconPosition.d.ts","sourceRoot":"","sources":["../../../lib/v7/renameIconPosition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAA+C,MAAM,aAAa,CAAC;AAIjG,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UA+C7E"}

package/dist/es6/v7/renameIconPosition.js

@@ -0,0 +1,37 @@
+import { getImportRenameMap } from './utils/getImportRenameMap';
+export default function transformer(file, api, options) {
+    var j = api.jscodeshift;
+    var root = j(file.source);
+    var _a = getImportRenameMap(j, root, '@workday/canvas-kit-react/button'), containsCanvasImports = _a.containsCanvasImports, importMap = _a.importMap, styledMap = _a.styledMap;
+    if (!containsCanvasImports) {
+        return file.source;
+    }
+    root
+        .find(j.JSXElement, function (value) {
+        return value.openingElement.name.type === 'JSXIdentifier' &&
+            (value.openingElement.name.name ===
+                (importMap.PrimaryButton || importMap.SecondaryButton) ||
+                value.openingElement.name.name === (styledMap.PrimaryButton || styledMap.SecondaryButton));
+    })
+        .forEach(function (nodePath) {
+        var _a;
+        var findAttribute = function (name) { return function (item) {
+            return item.type === 'JSXAttribute' &&
+                item.name.type === 'JSXIdentifier' &&
+                item.name.name === name;
+        }; };
+        var attributes = nodePath.value.openingElement.attributes;
+        if (attributes) {
+            var iconPosition = attributes.find(findAttribute('iconPosition'));
+            if (((_a = iconPosition === null || iconPosition === void 0 ? void 0 : iconPosition.value) === null || _a === void 0 ? void 0 : _a.type) === 'StringLiteral') {
+                if (iconPosition.value.value === 'left') {
+                    iconPosition.value.value = 'start';
+                }
+                else {
+                    iconPosition.value.value = 'end';
+                }
+            }
+        }
+    });
+    return root.toSource();
+}

package/dist/es6/v7/renameIconRef.d.ts

@@ -0,0 +1,3 @@
+import { API, FileInfo, Options } from 'jscodeshift';
+export default function transformer(file: FileInfo, api: API, options: Options): string;
+//# sourceMappingURL=renameIconRef.d.ts.map

package/dist/es6/v7/renameIconRef.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renameIconRef.d.ts","sourceRoot":"","sources":["../../../lib/v7/renameIconRef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAgB,MAAM,aAAa,CAAC;AAgBlE,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UAiE7E"}

package/dist/es6/v7/renameIconRef.js

@@ -0,0 +1,70 @@
+import { getImportRenameMap } from './utils/getImportRenameMap';
+var inputsMap = {
+    '@workday/canvas-kit-react/icon': [
+        'AccentIcon',
+        'AppletIcon',
+        'SystemIcon',
+        'SystemIconCircle',
+        'Graphic',
+        'Svg',
+    ],
+};
+export default function transformer(file, api, options) {
+    var j = api.jscodeshift;
+    var root = j(file.source);
+    // defaultImports should be an array of local names that were imported using
+    // a default import from any of the modules listed in inputsMap. For example,
+    // given...
+    //
+    // ```
+    // import Checkbox from '@workday/canvas-kit-react/checkbox';
+    // import CanvasTextArea from '@workday/canvas-kit-react/text-area';
+    // import {TextInput} from '@workday/canvas-kit-react/text-input';
+    // import StatusIndicator from '@workday/canvas-kit-react/status-indicator';
+    // ```
+    //
+    // ... defaultImports should be set to `['Checkbox', 'CanvasTextArea']`
+    var defaultImports = [];
+    root.find(j.ImportDefaultSpecifier).forEach(function (nodePath) {
+        var _a;
+        var packageName = nodePath.parent.node.source.value;
+        var localName = (_a = nodePath.value.local) === null || _a === void 0 ? void 0 : _a.name;
+        if (packageName in inputsMap && localName) {
+            defaultImports.push(localName);
+        }
+    });
+    var runningSource = file.source;
+    var _loop_1 = function (inputPackageName) {
+        var currentRoot = j(runningSource);
+        var _a = getImportRenameMap(j, currentRoot, inputPackageName), containsCanvasImports = _a.containsCanvasImports, importMap = _a.importMap, styledMap = _a.styledMap;
+        if (containsCanvasImports) {
+            var inputNames_1 = inputsMap[inputPackageName];
+            currentRoot
+                .find(j.JSXIdentifier, function (value) { return value.name === 'iconRef'; })
+                .replaceWith(function (nodePath) {
+                var _a, _b, _c, _d;
+                var elementName = (_d = (_c = (_b = (_a = nodePath.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.value) === null || _c === void 0 ? void 0 : _c.name) === null || _d === void 0 ? void 0 : _d.name;
+                // Rewrite inputRef to ref if any of the following are true:
+                // (a) elementName was the name used in a default import of the current
+                //     input being processed (e.g., `import TextInput ...`)
+                // (b) elementName was the name used in a named import of the current
+                //     input being processed (e.g., `import {TextInput} ...`  or
+                //     `import {TextInput as CanvasTextInput} ...`)
+                // (c) elementName was created by calling `styled` on the current input
+                //     being processed (e.g., `const StyledTextInput = styled(TextInput)`)
+                if (defaultImports.includes(elementName) ||
+                    inputNames_1.map(function (n) { return importMap[n]; }).includes(elementName) ||
+                    inputNames_1.map(function (n) { return styledMap[n]; }).includes(elementName)) {
+                    return j.jsxIdentifier('ref');
+                }
+                return nodePath.value;
+            });
+            runningSource = currentRoot.toSource();
+        }
+    };
+    for (var _i = 0, _a = Object.keys(inputsMap); _i < _a.length; _i++) {
+        var inputPackageName = _a[_i];
+        _loop_1(inputPackageName);
+    }
+    return runningSource;
+}

package/dist/es6/v7/renameLayoutImports.d.ts

@@ -0,0 +1,4 @@
+import { Transform } from 'jscodeshift';
+declare const transform: Transform;
+export default transform;
+//# sourceMappingURL=renameLayoutImports.d.ts.map

package/dist/es6/v7/renameLayoutImports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renameLayoutImports.d.ts","sourceRoot":"","sources":["../../../lib/v7/renameLayoutImports.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAA6B,MAAM,aAAa,CAAC;AAoDlE,QAAA,MAAM,SAAS,EAAE,SAyEhB,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/dist/es6/v7/renameLayoutImports.js

@@ -0,0 +1,105 @@
+// used to filter our imports we want to keep in @workday/canvas-kit-labs-react/common
+var commonSpecifiers = [
+    'useTheme',
+    'ComponentStatesTable',
+    'permutateProps',
+    'useThemeRTL',
+    'useThemedRing',
+];
+var layoutSpecifiers = [
+    'Flex',
+    'Stack',
+    'StackProps',
+    'HStackProps',
+    'VStack',
+    'VStackProps',
+    'HStack',
+    'Box',
+    'BoxProps',
+    'FlexProps',
+    'ColorStyleProps',
+    'StackSpacing',
+    'StackDirection',
+    'StackStyleProps',
+    'FlexStyleProps',
+    'SpaceStyleProps',
+    'DepthStyleProps',
+    'BorderShorthandStyleProps',
+    'BorderColorStyleProps',
+    'BorderRadiusStyleProps',
+    'BorderLineStyleProps',
+    'BorderWidthStyleProps',
+    'BorderLogicalStyleProps',
+    'BorderStyleProps',
+    'border',
+    'ColorTokens',
+    'ColorStyleProps',
+    'color',
+    'FlexItemStyleProps',
+    'flexItem',
+    'PositionStandardProps',
+    'PositionLogicalProps',
+    'PositionStyleProps',
+    'position',
+];
+// 1. Gather all import specifiers from @workday/canvas-kit-labs-react/layout
+// 2. Filter through all imports from @workday/canvas-kit-labs-react/common and gather specifiers we care about
+// 3. If there's an existing @workday/canvas-kit-react/layout add gathered specifiers to that import
+// 4. If no existing import, create new import with specifiers and insert before closest canvas kit import
+var transform = function (file, api) {
+    var j = api.jscodeshift;
+    var root = j(file.source);
+    var reactLayoutSpecifiers = [];
+    var foundImport = [];
+    root
+        .find(j.ImportDeclaration, {
+        source: { value: function (value) { return value.includes('@workday/canvas-kit-labs-react'); } },
+    })
+        .forEach(function (nodePath) {
+        var _a;
+        nodePath.value.specifiers = (_a = nodePath.value.specifiers) === null || _a === void 0 ? void 0 : _a.filter(function (specifier) {
+            var _a, _b, _c, _d;
+            if (specifier.type === 'ImportSpecifier' &&
+                !commonSpecifiers.includes(specifier.imported.name)) {
+                if (((_a = specifier === null || specifier === void 0 ? void 0 : specifier.local) === null || _a === void 0 ? void 0 : _a.name) !== undefined &&
+                    layoutSpecifiers.includes((_b = specifier === null || specifier === void 0 ? void 0 : specifier.local) === null || _b === void 0 ? void 0 : _b.name)) {
+                    reactLayoutSpecifiers.push({
+                        importedName: (_c = specifier === null || specifier === void 0 ? void 0 : specifier.local) === null || _c === void 0 ? void 0 : _c.name,
+                        name: (_d = specifier === null || specifier === void 0 ? void 0 : specifier.imported) === null || _d === void 0 ? void 0 : _d.name,
+                    });
+                    return false;
+                }
+            }
+            return true;
+        });
+        foundImport.push(nodePath);
+    });
+    var existingLayoutImports = root.find(j.ImportDeclaration, {
+        source: { value: '@workday/canvas-kit-react/layout' },
+    });
+    var mapToSpecifiers = function (specifier) {
+        return j.importSpecifier(j.identifier(specifier.name), specifier.importedName ? j.identifier(specifier.importedName) : undefined);
+    };
+    // add to existing import
+    if (existingLayoutImports.length) {
+        existingLayoutImports.forEach(function (nodePath) {
+            var _a;
+            nodePath.value.specifiers = (_a = nodePath.value.specifiers) === null || _a === void 0 ? void 0 : _a.concat(reactLayoutSpecifiers.map(mapToSpecifiers));
+        });
+    }
+    else {
+        // create new import
+        if (foundImport.length) {
+            foundImport[0].insertBefore(j.importDeclaration(reactLayoutSpecifiers.map(mapToSpecifiers), j.stringLiteral('@workday/canvas-kit-react/layout')));
+        }
+    }
+    foundImport.forEach(function (importPath) {
+        var _a;
+        if (((_a = importPath.value.specifiers) === null || _a === void 0 ? void 0 : _a.length) === 0 ||
+            importPath.value.source.value === '@workday/canvas-kit-labs-react/layout') {
+            importPath.prune();
+        }
+    });
+    return root.toSource();
+};
+export default transform;

package/dist/es6/v7/updateDisclosureShowHide.d.ts

@@ -0,0 +1,3 @@
+import { API, FileInfo, Options } from 'jscodeshift';
+export default function transformer(file: FileInfo, api: API, options: Options): string;
+//# sourceMappingURL=updateDisclosureShowHide.d.ts.map

package/dist/es6/v7/updateDisclosureShowHide.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateDisclosureShowHide.d.ts","sourceRoot":"","sources":["../../../lib/v7/updateDisclosureShowHide.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,QAAQ,EAA6B,OAAO,EAAC,MAAM,aAAa,CAAC;AAK9E,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UAiH7E"}

package/dist/es6/v7/updateDisclosureShowHide.js

@@ -0,0 +1,96 @@
+import { getImportRenameMap } from './utils/getImportRenameMap';
+var keys = function (input) { return Object.keys(input); };
+export default function transformer(file, api, options) {
+    var j = api.jscodeshift;
+    var root = j(file.source);
+    var _a = getImportRenameMap(j, root), containsCanvasImports = _a.containsCanvasImports, importMap = _a.importMap;
+    if (!containsCanvasImports) {
+        return file.source;
+    }
+    var disclosureModels = [
+        'useDisclosureModel',
+        'usePopupModel',
+        'useModalModel',
+        'useDialogModel',
+    ];
+    // inverse the import map. It is more useful this way for this function
+    var imports = Object.keys(importMap).reduce(function (result, key) {
+        result[importMap[key]] = key;
+        return result;
+    }, {});
+    root.find(j.CallExpression).forEach(function (nodePath) {
+        var value = nodePath.value;
+        // check if the identifier was imported from CK AND follows the `use{*}Model` naming convention
+        if (value.callee.type === 'Identifier' &&
+            disclosureModels.includes(imports[value.callee.name])) {
+            // loop over all the arguments of the `use{*}Model` hook
+            value.arguments.forEach(function (argument) {
+                // look for object expressions: `use{*}Model({ /* here */ })`
+                if (argument.type === 'ObjectExpression') {
+                    // loop over all the properties looking for `ObjectMethod` and `ObjectProperties` where
+                    // the value is a function matching `on{*}` or `should{*}` naming convention
+                    argument.properties.forEach(function (property) {
+                        // If it is an `ObjectMethod` or an `ObjectProperty` with an arrow function expression:
+                        // {
+                        //   onShow() {}, // ObjectMethod
+                        //   onHide: () => {}, ObjectProperty with arrow function expression
+                        // }
+                        if ((property.type === 'ObjectMethod' ||
+                            (property.type === 'ObjectProperty' &&
+                                property.value.type === 'ArrowFunctionExpression')) &&
+                            property.key.type === 'Identifier') {
+                            var propertyName_1 = property.key.name;
+                            // Both types have a `params`, but are at different places in the AST
+                            var params_1 = property.type === 'ObjectMethod'
+                                ? property.params
+                                : property.value.type === 'ArrowFunctionExpression'
+                                    ? property.value.params
+                                    : [];
+                            // create a mapping for param names of callbacks and guards. This makes the logic more
+                            // difficult to follow, but decreases duplication
+                            var paramMapping_1 = {
+                                on: ['event'],
+                                should: ['event'],
+                            };
+                            // We will be overriding the params with this variable later
+                            var finalParams_1 = [];
+                            // loop over each `paramMapping` type. `on*` and `should*` functions have different signatures
+                            keys(paramMapping_1).forEach(function (key) {
+                                // matches `onShow` and `shouldShow`
+                                if (new RegExp(key + "[A-Za-z]+").test(propertyName_1)) {
+                                    params_1.forEach(function (param) {
+                                        if (param.type === 'ObjectPattern') {
+                                            param.properties.forEach(function (property) {
+                                                if (property.type === 'ObjectProperty' &&
+                                                    property.key.type === 'Identifier') {
+                                                    if (property.value.type === 'Identifier' ||
+                                                        property.value.type === 'ObjectPattern') {
+                                                        var index = paramMapping_1[key].indexOf(property.key.name);
+                                                        // use `property.value` instead of `property.key.name` in case they
+                                                        // renamed it example `shouldShow({ data: myData })`. The key name is
+                                                        // `data` while the value is `myData`
+                                                        finalParams_1[index] = property.value;
+                                                    }
+                                                }
+                                            });
+                                        }
+                                    });
+                                    // `ObjectMethod` and `ObjectProperty` have params in a different place in the
+                                    // AST, so apply `finalParams` where appropriate
+                                    if (property.type === 'ObjectMethod') {
+                                        property.params = finalParams_1;
+                                    }
+                                    else if (property.type === 'ObjectProperty' &&
+                                        property.value.type === 'ArrowFunctionExpression') {
+                                        property.value.params = finalParams_1;
+                                    }
+                                }
+                            });
+                        }
+                    });
+                }
+            });
+        }
+    });
+    return root.toSource();
+}

package/dist/es6/v7/updateModelSignatures.d.ts

@@ -0,0 +1,3 @@
+import { API, FileInfo, Options } from 'jscodeshift';
+export default function transformer(file: FileInfo, api: API, options: Options): string;
+//# sourceMappingURL=updateModelSignatures.d.ts.map

package/dist/es6/v7/updateModelSignatures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateModelSignatures.d.ts","sourceRoot":"","sources":["../../../lib/v7/updateModelSignatures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,QAAQ,EAA6B,OAAO,EAAC,MAAM,aAAa,CAAC;AAK9E,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UA0G7E"}

package/dist/es6/v7/updateModelSignatures.js

@@ -0,0 +1,90 @@
+import { getImportRenameMap } from './utils/getImportRenameMap';
+var keys = function (input) { return Object.keys(input); };
+export default function transformer(file, api, options) {
+    var j = api.jscodeshift;
+    var root = j(file.source);
+    var _a = getImportRenameMap(j, root), containsCanvasImports = _a.containsCanvasImports, importMap = _a.importMap;
+    if (!containsCanvasImports) {
+        return file.source;
+    }
+    // inverse the import map. It is more useful this way for this function
+    var imports = Object.keys(importMap).reduce(function (result, key) {
+        result[importMap[key]] = key;
+        return result;
+    }, {});
+    root.find(j.CallExpression).forEach(function (nodePath) {
+        var value = nodePath.value;
+        // check if the identifier was imported from CK AND follows the `use{*}Model` naming convention
+        if (value.callee.type === 'Identifier' &&
+            /use[a-zA-Z]+Model/.test(imports[value.callee.name])) {
+            // loop over all the arguments of the `use{*}Model` hook
+            value.arguments.forEach(function (argument) {
+                // look for object expressions: `use{*}Model({ /* here */ })`
+                if (argument.type === 'ObjectExpression') {
+                    // loop over all the properties looking for `ObjectMethod` and `ObjectProperties` where
+                    // the value is a function matching `on{*}` or `should{*}` naming convention
+                    argument.properties.forEach(function (property) {
+                        // If it is an `ObjectMethod` or an `ObjectProperty` with an arrow function expression:
+                        // {
+                        //   onShow() {}, // ObjectMethod
+                        //   onHide: () => {}, ObjectProperty with arrow function expression
+                        // }
+                        if ((property.type === 'ObjectMethod' ||
+                            (property.type === 'ObjectProperty' &&
+                                property.value.type === 'ArrowFunctionExpression')) &&
+                            property.key.type === 'Identifier') {
+                            var propertyName_1 = property.key.name;
+                            // Both types have a `params`, but are at different places in the AST
+                            var params_1 = property.type === 'ObjectMethod'
+                                ? property.params
+                                : property.value.type === 'ArrowFunctionExpression'
+                                    ? property.value.params
+                                    : [];
+                            // create a mapping for param names of callbacks and guards. This makes the logic more
+                            // difficult to follow, but decreases duplication
+                            var paramMapping_1 = {
+                                on: ['data', 'state'],
+                                should: ['data', 'prevState'],
+                            };
+                            // We will be overriding the params with this variable later
+                            var finalParams_1 = [];
+                            // loop over each `paramMapping` type. `on*` and `should*` functions have different signatures
+                            keys(paramMapping_1).forEach(function (key) {
+                                // matches `onShow` and `shouldShow`
+                                if (new RegExp(key + "[A-Za-z]+").test(propertyName_1)) {
+                                    params_1.forEach(function (param) {
+                                        if (param.type === 'ObjectPattern') {
+                                            param.properties.forEach(function (property) {
+                                                if (property.type === 'ObjectProperty' &&
+                                                    property.key.type === 'Identifier') {
+                                                    if (property.value.type === 'Identifier' ||
+                                                        property.value.type === 'ObjectPattern') {
+                                                        var index = paramMapping_1[key].indexOf(property.key.name);
+                                                        // use `property.value` instead of `property.key.name` in case they
+                                                        // renamed it example `shouldShow({ data: myData })`. The key name is
+                                                        // `data` while the value is `myData`
+                                                        finalParams_1[index] = property.value;
+                                                    }
+                                                }
+                                            });
+                                        }
+                                    });
+                                    // `ObjectMethod` and `ObjectProperty` have params in a different place in the
+                                    // AST, so apply `finalParams` where appropriate
+                                    if (property.type === 'ObjectMethod') {
+                                        property.params = finalParams_1;
+                                    }
+                                    else if (property.type === 'ObjectProperty' &&
+                                        property.value.type === 'ArrowFunctionExpression') {
+                                        property.value.params = finalParams_1;
+                                    }
+                                }
+                            });
+                        }
+                    });
+                }
+            });
+        }
+    });
+    return root.toSource();
+}

package/dist/es6/v7/updateSegmentedControl.d.ts

@@ -0,0 +1,3 @@
+import { API, FileInfo, Options } from 'jscodeshift';
+export default function transformer(file: FileInfo, api: API, options: Options): string;
+//# sourceMappingURL=updateSegmentedControl.d.ts.map

package/dist/es6/v7/updateSegmentedControl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateSegmentedControl.d.ts","sourceRoot":"","sources":["../../../lib/v7/updateSegmentedControl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAa,MAAM,aAAa,CAAC;AAI/D,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UAgC7E"}

package/dist/es6/v7/updateSegmentedControl.js

@@ -0,0 +1,24 @@
+import { getImportRenameMap } from './utils/getImportRenameMap';
+export default function transformer(file, api, options) {
+    var j = api.jscodeshift;
+    var root = j(file.source);
+    var _a = getImportRenameMap(j, root, '@workday/canvas-kit-react/segmented-control'), containsCanvasImports = _a.containsCanvasImports, importMap = _a.importMap, styledMap = _a.styledMap;
+    if (!containsCanvasImports) {
+        return file.source;
+    }
+    root
+        .find(j.JSXElement, function (value) {
+        return value.openingElement.name.type === 'JSXIdentifier' &&
+            (value.openingElement.name.name === importMap.SegmentedControl ||
+                value.openingElement.name.name === styledMap.SegmentedControl);
+    })
+        .forEach(function (nodePath) {
+        for (var _i = 0, _a = nodePath.value.children || []; _i < _a.length; _i++) {
+            var child = _a[_i];
+            if (child.type === 'JSXElement' && child.openingElement.name.type === 'JSXIdentifier') {
+                child.openingElement.name.name = 'SegmentedControl.Button';
+            }
+        }
+    });
+    return root.toSource();
+}

package/dist/es6/v7/updateTabs.d.ts

@@ -0,0 +1,3 @@
+import { API, FileInfo, Options } from 'jscodeshift';
+export default function transformer(file: FileInfo, api: API, options: Options): string;
+//# sourceMappingURL=updateTabs.d.ts.map

package/dist/es6/v7/updateTabs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateTabs.d.ts","sourceRoot":"","sources":["../../../lib/v7/updateTabs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,EAAC,MAAM,aAAa,CAAC;AAGnD,MAAM,CAAC,OAAO,UAAU,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,UAuD7E"}

package/dist/es6/v7/updateTabs.js

@@ -0,0 +1,48 @@
+import { getImportRenameMap } from './utils/getImportRenameMap';
+export default function transformer(file, api, options) {
+    var j = api.jscodeshift;
+    var root = j(file.source);
+    var _a = getImportRenameMap(j, root), containsCanvasImports = _a.containsCanvasImports, importMap = _a.importMap;
+    if (!containsCanvasImports) {
+        return file.source;
+    }
+    root
+        // Find <Tabs
+        .find(j.JSXOpeningElement, { name: { object: { name: importMap.Tabs } } })
+        // Filter for <Tabs.Item and <Tabs.Panel
+        .filter(function (path) {
+        return (path.value.name.type === 'JSXMemberExpression' &&
+            (path.value.name.property.name === 'Item' || path.value.name.property.name === 'Panel'));
+    })
+        .forEach(function (nodePath) {
+        var _a;
+        nodePath.value.attributes = (_a = nodePath.value.attributes) === null || _a === void 0 ? void 0 : _a.map(function (attribute) {
+            if (attribute.type === 'JSXAttribute' &&
+                attribute.name.type === 'JSXIdentifier' &&
+                attribute.name.name === 'name') {
+                attribute.name.name = 'data-id';
+            }
+            return attribute;
+        });
+    });
+    root
+        // find <Tabs.Menu.Item
+        .find(j.JSXOpeningElement, {
+        name: {
+            object: { object: { name: importMap.Tabs }, property: { name: 'Menu' } },
+            property: { name: 'Item' },
+        },
+    })
+        .forEach(function (nodePath) {
+        var _a;
+        nodePath.value.attributes = (_a = nodePath.value.attributes) === null || _a === void 0 ? void 0 : _a.map(function (attribute) {
+            if (attribute.type === 'JSXAttribute' &&
+                attribute.name.type === 'JSXIdentifier' &&
+                attribute.name.name === 'name') {
+                attribute.name.name = 'data-id';
+            }
+            return attribute;
+        });
+    });
+    return root.toSource();
+}

package/dist/es6/v7/utils/getImportRenameMap.d.ts

@@ -0,0 +1,7 @@
+import { Collection, JSCodeshift } from 'jscodeshift';
+export declare function getImportRenameMap(j: JSCodeshift, root: Collection<any>, packageName?: string): {
+    containsCanvasImports: boolean;
+    importMap: Record<string, string>;
+    styledMap: Record<string, string>;
+};
+//# sourceMappingURL=getImportRenameMap.d.ts.map

package/dist/es6/v7/utils/getImportRenameMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getImportRenameMap.d.ts","sourceRoot":"","sources":["../../../../lib/v7/utils/getImportRenameMap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,WAAW,EAAiB,MAAM,aAAa,CAAC;AAEpE,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,EAAE,WAAW,SAAK;;;;EA2DzF"}

package/dist/es6/v7/utils/getImportRenameMap.js

@@ -0,0 +1,52 @@
+export function getImportRenameMap(j, root, packageName) {
+    if (packageName === void 0) { packageName = ''; }
+    var containsCanvasImports = false;
+    // build import name remapping - in case someone renamed imports...
+    // i.e. `import { IconButton as StyledIconButton } ...`
+    var importMap = {};
+    var styledMap = {};
+    root.find(j.ImportDeclaration, function (node) {
+        // imports our module
+        var value = node.source.value;
+        if (typeof value === 'string' &&
+            (value === '@workday/canvas-kit-react' ||
+                value.startsWith('@workday/canvas-kit-react/') ||
+                value === packageName)) {
+            containsCanvasImports = true;
+            (node.specifiers || []).forEach(function (specifier) {
+                if (specifier.type === 'ImportSpecifier') {
+                    if (!specifier.local || specifier.local.name === specifier.imported.name) {
+                        importMap[specifier.imported.name] = specifier.imported.name;
+                    }
+                    else {
+                        importMap[specifier.imported.name] = specifier.local.name;
+                    }
+                }
+            });
+        }
+        return false;
+    });
+    root
+        .find(j.CallExpression, function (node) {
+        if (node.callee.type === 'Identifier' &&
+            node.callee.name === 'styled' &&
+            node.arguments[0].type === 'Identifier') {
+            return true;
+        }
+        return false;
+    })
+        .forEach(function (nodePath) {
+        // const StyledName = styled(OriginalName)({})
+        // const StyledName = styled(OriginalName)`` // Tagged template
+        if ((nodePath.parent.value.type === 'CallExpression' ||
+            nodePath.parent.value.type === 'TaggedTemplateExpression') &&
+            nodePath.parent.parent.value.type === 'VariableDeclarator' &&
+            nodePath.parent.parent.value.id.type === 'Identifier') {
+            var styledName = nodePath.parent.parent.value.id.name;
+            if (nodePath.value.arguments[0].type === 'Identifier') {
+                styledMap[nodePath.value.arguments[0].name] = styledName;
+            }
+        }
+    });
+    return { containsCanvasImports: containsCanvasImports, importMap: importMap, styledMap: styledMap };
+}

package/dist/es6/v7/utils/hasImportSpecifiers.d.ts

@@ -0,0 +1,20 @@
+import { Collection, API } from 'jscodeshift';
+/**
+ * Search for import statements for a package and specific import specifiers. This
+ * is useful for codemods to skip files that don't contain import specifiers that
+ * require codemoding.
+ *
+ * @example
+ * const hasImports = hasImportSpecifiers(
+ *   api,
+ *   root,
+ *   '@workday/canvas-kit-react/cookie-banner',
+ *   ['CookieBanner', 'CookieBannerProps']
+ * )
+ *
+ * if (!hasImports) {
+ *   return file.source
+ * }
+ */
+export declare function hasImportSpecifiers(api: API, root: Collection<any>, packageName: string | string[], specifiers: string[]): boolean;
+//# sourceMappingURL=hasImportSpecifiers.d.ts.map

package/dist/es6/v7/utils/hasImportSpecifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasImportSpecifiers.d.ts","sourceRoot":"","sources":["../../../../lib/v7/utils/hasImportSpecifiers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAE,GAAG,EAAC,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,EACrB,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,EAC9B,UAAU,EAAE,MAAM,EAAE,WAkCrB"}

package/dist/es6/v7/utils/hasImportSpecifiers.js

@@ -0,0 +1,46 @@
+/**
+ * Search for import statements for a package and specific import specifiers. This
+ * is useful for codemods to skip files that don't contain import specifiers that
+ * require codemoding.
+ *
+ * @example
+ * const hasImports = hasImportSpecifiers(
+ *   api,
+ *   root,
+ *   '@workday/canvas-kit-react/cookie-banner',
+ *   ['CookieBanner', 'CookieBannerProps']
+ * )
+ *
+ * if (!hasImports) {
+ *   return file.source
+ * }
+ */
+export function hasImportSpecifiers(api, root, packageName, specifiers) {
+    var j = api.jscodeshift;
+    return !!root.find(j.ImportDeclaration, function (nodePath) {
+        var value = nodePath.source.value;
+        // package name was found
+        if (typeof packageName === 'string'
+            ? value === packageName
+            : packageName.includes(value)) {
+            return true;
+        }
+        // Extract the main package(s) from the import, and test specifiers against that package
+        var mainPackage = (typeof packageName === 'string' ? [packageName] : packageName).map(function (s) {
+            return s
+                .split('/')
+                .slice(0, -1)
+                .join('/');
+        });
+        if (mainPackage.includes(value)) {
+            return !!(nodePath.specifiers || []).find(function (specifier) {
+                if (specifier.type === 'ImportSpecifier') {
+                    var specifierName = specifier.imported.name;
+                    return specifiers.includes(specifierName);
+                }
+                return false;
+            });
+        }
+        return false;
+    });
+}

package/index.js

@@ -21,6 +21,13 @@ const {_: commands, path} = require('yargs')
       describe: chalk.gray('The path to execute the transform in (recursively).'),
     });
   })
+  .command('v7 [path]', chalk.gray('Canvas Kit v6 > v7 migration transform'), yargs => {
+    yargs.positional('path', {
+      type: 'string',
+      default: '.',
+      describe: chalk.gray('The path to execute the transform in (recursively).'),
+    });
+  })
   .demandCommand(1, chalk.red.bold('You must provide a transform to apply.'))
   .strictCommands()
   .fail((msg, err, yargs) => {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@workday/canvas-kit-codemod",
   "author": "Workday, Inc. (https://www.workday.com)",
   "license": "Apache-2.0",
-  "version": "6.8.9",
+  "version": "6.9.0-next.5+1b09db00",
   "description": "A collection of codemods for use on Workday Canvas Kit packages.",
   "main": "dist/es6/index.js",
   "sideEffects": false,
@@ -11,7 +11,8 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Workday/canvas-kit.git"
+    "url": "https://github.com/workday/canvas-kit.git",
+    "directory": "modules/codemod"
   },
   "files": [
     "dist/",
@@ -42,5 +43,5 @@
     "test": "TZ=UTC jest -c ../../jest.config.js",
     "typecheck:src": "tsc -p . --noEmit --incremental false"
   },
-  "gitHead": "9616dcc6b1b17b48a2463a29b3db49b55708ee5b"
+  "gitHead": "1b09db0053a1c1698eb243c94ce80655f7527a63"
 }