@workday/canvas-kit-codemod 7.1.4 → 7.2.0-427-next.2

package/dist/es6/v9/compoundToast.js

@@ -0,0 +1,121 @@
+import { getImportRenameMap } from '../v7/utils/getImportRenameMap';
+import { hasImportSpecifiers } from '../v6/utils';
+const toastPackage = '@workday/canvas-kit-react/toast';
+export default function transformer(file, api, options) {
+    const j = api.jscodeshift;
+    const root = j(file.source);
+    if (!hasImportSpecifiers(api, root, toastPackage, ['Toast'])) {
+        return file.source;
+    }
+    const { importMap, styledMap } = getImportRenameMap(j, root, '@workday/canvas-kit-react/toast');
+    root
+        .find(j.JSXElement, (value) => value.openingElement.name.type === 'JSXIdentifier' &&
+        (value.openingElement.name.name === importMap.Toast ||
+            value.openingElement.name.name === styledMap.Toast))
+        .forEach(nodePath => {
+        var _a, _b, _c;
+        // Toast Body JSX
+        const ToastBodyJSX = j.jsxMemberExpression(j.jsxIdentifier(importMap.Toast), j.jsxIdentifier('Body'));
+        // Toast CloseIcon JSX
+        const ToastCloseJSX = j.jsxMemberExpression(j.jsxIdentifier(importMap.Toast), j.jsxIdentifier('Close'));
+        // Toast Message JSX
+        const ToastMessageJSX = j.jsxMemberExpression(j.jsxIdentifier(importMap.Toast), j.jsxIdentifier('Message'));
+        // Toast Icon JSX
+        const ToastIconJSX = j.jsxMemberExpression(j.jsxIdentifier(importMap.Toast), j.jsxIdentifier('Icon'));
+        // Toast Link JSX
+        const ToastLinkJSX = j.jsxMemberExpression(j.jsxIdentifier(importMap.Toast), j.jsxIdentifier('Link'));
+        // Attributes
+        const attributes = nodePath.value.openingElement.attributes;
+        const defaultIconAttributes = [
+            j.jsxAttribute(j.jsxIdentifier('color'), j.stringLiteral('greenApple400')),
+            j.jsxAttribute(j.jsxIdentifier('icon'), j.jsxExpressionContainer(j.jsxIdentifier('checkIcon'))),
+        ];
+        const unchangedIconAttributes = attributes === null || attributes === void 0 ? void 0 : attributes.filter(attr => attr.type === 'JSXAttribute' &&
+            typeof attr.name.name === 'string' &&
+            /icon|iconColor/g.test(attr.name.name));
+        const updatedIconAttrs = unchangedIconAttributes === null || unchangedIconAttributes === void 0 ? void 0 : unchangedIconAttributes.map(specifier => {
+            if (specifier.type === 'JSXAttribute' && specifier.name.name === 'iconColor') {
+                specifier.name.name = 'color';
+            }
+            return specifier;
+        });
+        const chooseIconAttrs = unchangedIconAttributes && unchangedIconAttributes.length
+            ? updatedIconAttrs
+            : defaultIconAttributes;
+        const closeAttributes = attributes === null || attributes === void 0 ? void 0 : attributes.filter(attr => attr.type === 'JSXAttribute' && attr.name.name === 'onClose');
+        const linkAttributes = attributes === null || attributes === void 0 ? void 0 : attributes.filter(attr => attr.type === 'JSXAttribute' &&
+            (attr.name.name === 'actionText' || attr.name.name === 'onActionClick'));
+        // Elements
+        const OpeningIconJSX = j.jsxOpeningElement(ToastIconJSX, chooseIconAttrs, true);
+        const IconElement = j.jsxElement(OpeningIconJSX);
+        // Add `import {checkIcon} from '@workday/canvas-system-icons-web'`
+        // when there's a default toast
+        const lastImport = root.find(j.ImportDeclaration).at(-1);
+        if (lastImport && !(unchangedIconAttributes === null || unchangedIconAttributes === void 0 ? void 0 : unchangedIconAttributes.length)) {
+            lastImport.insertAfter(j.importDeclaration([j.importSpecifier(j.identifier('checkIcon'))], j.stringLiteral('@workday/canvas-system-icons-web')));
+        }
+        const lineBreakStart = j.jsxText('\n  ');
+        const lineBreakEnd = j.jsxText('\n');
+        // Filter out all old props
+        const filteredAttrNames = [
+            'actionText',
+            'icon',
+            'iconColor',
+            'onActionClick',
+            'onClose',
+            'color',
+        ];
+        const filterAttr = (_a = nodePath.value.openingElement.attributes) === null || _a === void 0 ? void 0 : _a.filter(attr => {
+            return !(attr.type === 'JSXAttribute' &&
+                typeof attr.name.name === 'string' &&
+                filteredAttrNames.includes(attr.name.name));
+        });
+        nodePath.value.openingElement.attributes = filterAttr;
+        const OpeningCloseElement = j.jsxOpeningElement(ToastCloseJSX, closeAttributes, true);
+        const CloseElement = j.jsxElement(OpeningCloseElement);
+        // grab the onActionClick attr
+        const onActionClickAttr = linkAttributes === null || linkAttributes === void 0 ? void 0 : linkAttributes.filter(attr => attr.type === 'JSXAttribute' && attr.name.name === 'onActionClick');
+        // rename onActionClick to onClick for the Toast.Link component
+        const renameOnActionClick = onActionClickAttr === null || onActionClickAttr === void 0 ? void 0 : onActionClickAttr.map(attr => {
+            if (attr.type === 'JSXAttribute') {
+                attr.name.name = 'onClick';
+            }
+            return attr;
+        });
+        // grab the actionText prop
+        const actionTextAttr = linkAttributes === null || linkAttributes === void 0 ? void 0 : linkAttributes.find(attr => attr.type === 'JSXAttribute' && attr.name.name === 'actionText');
+        const actionText = actionTextAttr &&
+            actionTextAttr.type === 'JSXAttribute' &&
+            ((_b = actionTextAttr.value) === null || _b === void 0 ? void 0 : _b.type) === 'StringLiteral'
+            ? [actionTextAttr.value]
+            : [];
+        const LinkElement = j.jsxElement(j.jsxOpeningElement(ToastLinkJSX, renameOnActionClick), j.jsxClosingElement(ToastLinkJSX), actionText);
+        // Toast Message JSX inclduing children which should be the string
+        const MessageElement = j.jsxElement(j.jsxOpeningElement(ToastMessageJSX), j.jsxClosingElement(ToastMessageJSX), nodePath.value.children);
+        if (linkAttributes && (linkAttributes === null || linkAttributes === void 0 ? void 0 : linkAttributes.length)) {
+            // If there's a link, add mode="dialog" to the main Toast component for accessibility
+            nodePath.value.openingElement.attributes = [
+                j.jsxAttribute(j.jsxIdentifier('mode'), j.stringLiteral('dialog')),
+            ];
+        }
+        // Body element including Message and its children
+        const BodyElement = j.jsxElement(j.jsxOpeningElement(ToastBodyJSX), j.jsxClosingElement(ToastBodyJSX), [lineBreakStart, MessageElement, lineBreakEnd]);
+        // If there's an actionText or onActionClick, add the Toast.Link with its attributes inside Toast.Body
+        if (linkAttributes && linkAttributes.length) {
+            (_c = BodyElement.children) === null || _c === void 0 ? void 0 : _c.push(LinkElement, lineBreakEnd);
+        }
+        // Default Toast with no Close or Link
+        nodePath.value.children = [
+            lineBreakStart,
+            IconElement,
+            lineBreakEnd,
+            BodyElement,
+            lineBreakEnd,
+        ];
+        // If there's an onClose, add the Toast.Close with its attributes
+        if (closeAttributes && (closeAttributes === null || closeAttributes === void 0 ? void 0 : closeAttributes.length)) {
+            nodePath.value.children.push(CloseElement, lineBreakEnd);
+        }
+    });
+    return root.toSource();
+}

package/dist/es6/v9/deprecateStack.d.ts

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

package/dist/es6/v9/deprecateStack.d.ts.map

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

package/dist/es6/v9/deprecateStack.js

@@ -0,0 +1,275 @@
+const mainPackage = '@workday/canvas-kit-react';
+const stackPackage = '@workday/canvas-kit-react/layout';
+const stackImportNames = ['Stack', 'HStack', 'VStack'];
+const stackImportProps = ['StackProps', 'HStackProps', 'VStackProps', 'StackStyleProps'];
+const altImportSpecifier = ['ActionBar', 'Menu', 'Pagination', 'Tabs'];
+const altImportNamesIncludes = ['action-bar', 'menu', 'pagination', 'tabs'];
+const altPackages = altImportNamesIncludes.map(name => `${mainPackage}/${name}`);
+export default function transformer(file, api, options) {
+    const j = api.jscodeshift;
+    const root = j(file.source);
+    let hasStackImports = false;
+    const importedComponentNames = [];
+    // This toggles the failsafe that prevents us from accidentally transforming something unintentionally.
+    root.find(j.ImportDeclaration, (nodePath) => {
+        const value = nodePath.source.value;
+        // If there's an import from ActionBar, Menu, Pagination or Tabs package,
+        // set the import boolean check to true
+        // If there's an import from the main package, check to see if Stack, ActionBar,
+        // Menu, Pagination or Tabs or Stackprops are among the named imports
+        // e.g. import {Stack} from '@workday/canvas-kit-react/layout';
+        // e.g. import {Menu} from '@workday/canvas-kit-react/menu';
+        if (typeof value === 'string' &&
+            (value === mainPackage || value === stackPackage || altPackages.includes(value))) {
+            (nodePath.specifiers || []).forEach(specifier => {
+                if ((specifier.type === 'ImportSpecifier' &&
+                    stackImportNames.includes(specifier.imported.name)) ||
+                    (specifier.type === 'ImportSpecifier' &&
+                        stackImportProps.includes(specifier.imported.name)) ||
+                    (specifier.type === 'ImportSpecifier' &&
+                        altImportSpecifier.includes(specifier.imported.name))) {
+                    importedComponentNames.push(specifier.imported.name);
+                    hasStackImports = true;
+                }
+            });
+        }
+        return false;
+    });
+    // Failsafe to skip transforms unless a specific import is detected
+    if (!hasStackImports) {
+        return root.toSource();
+    }
+    root
+        .find(j.ImportDeclaration, {
+        source: { value: (value) => value.includes(mainPackage) },
+    })
+        .forEach(nodePath => {
+        var _a, _b;
+        (_a = nodePath.value.specifiers) === null || _a === void 0 ? void 0 : _a.forEach(specifier => {
+            if (specifier.type === 'ImportSpecifier') {
+                //  `import {Stack}` becomes `import {Flex}`
+                //  `import {HStack}` becomes `import {Flex}`
+                //  `import {VStack}` becomes `import {Flex}`
+                if (stackImportNames.includes(specifier.imported.name)) {
+                    specifier.imported.name = 'Flex';
+                }
+            }
+            return specifier;
+        });
+        nodePath.value.specifiers = (_b = nodePath.value.specifiers) === null || _b === void 0 ? void 0 : _b.filter((specifier, index, specifiers) => {
+            if (specifier.type === 'ImportSpecifier' &&
+                specifier.imported &&
+                specifier.imported.type === 'Identifier') {
+                return (specifiers.findIndex(s => {
+                    return (s.type === 'ImportSpecifier' &&
+                        s.imported.type === 'Identifier' &&
+                        s.imported.name === specifier.imported.name);
+                }) === index);
+            }
+            return true;
+        });
+    });
+    root
+        .find(j.ImportDeclaration, {
+        source: { value: (value) => value.includes(mainPackage) },
+    })
+        .forEach(nodePath => {
+        var _a, _b;
+        (_a = nodePath.value.specifiers) === null || _a === void 0 ? void 0 : _a.forEach(specifier => {
+            if (specifier.type === 'ImportSpecifier') {
+                //  `import {StackProps}` becomes `import {FlexProps}`
+                //  `import {HStackProps}` becomes `import {FlexProps}`
+                //  `import {VStackProps}` becomes `import {FlexProps}`
+                //  `import {StackStyleProps}` becomes `import {FlexProps}`
+                if (stackImportProps.includes(specifier.imported.name)) {
+                    specifier.imported.name = `FlexProps`;
+                }
+            }
+            return specifier;
+        });
+        nodePath.value.specifiers = (_b = nodePath.value.specifiers) === null || _b === void 0 ? void 0 : _b.filter((specifier, index, specifiers) => {
+            if (specifier.type === 'ImportSpecifier' &&
+                specifier.imported &&
+                specifier.imported.type === 'Identifier') {
+                return (specifiers.findIndex(s => {
+                    return (s.type === 'ImportSpecifier' &&
+                        s.imported.type === 'Identifier' &&
+                        s.imported.name === specifier.imported.name);
+                }) === index);
+            }
+            return true;
+        });
+    });
+    // Transform StackProps type references
+    // e.g. `type CustomProps = StackProps;` becomes `type CustomProps = FlexProps;`
+    // Transform HStackProps type references
+    // e.g. `type CustomProps = HStackProps;` becomes `type CustomProps = FlexProps;`
+    // Transform VStackProps type references
+    // e.g. `type CustomProps = VStackProps;` becomes `type CustomProps = FlexProps;`
+    const typeNames = ['StackProps', 'HStackProps', 'VStackProps', 'StackStyleProps'];
+    root
+        .find(j.TSTypeReference, {
+        typeName: {
+            type: 'Identifier',
+            name: (value) => typeNames.includes(value),
+        },
+    })
+        .forEach(nodePath => {
+        const identifier = nodePath.value.typeName;
+        identifier.name = `FlexProps`;
+    });
+    // Transform StackProps type interface declaration references
+    // e.g. `interface CustomProps extends StackProps` becomes `interface CustomProps extends FlexProps`
+    root.find(j.TSInterfaceDeclaration).forEach(nodePath => {
+        var _a;
+        // If the interface is extending StackProps, transform the extension name to FlexProps
+        (_a = nodePath.node.extends) === null || _a === void 0 ? void 0 : _a.forEach(typeExtension => {
+            if (typeExtension.expression.type === 'Identifier') {
+                const typeExtensionName = typeExtension.expression.name;
+                if (typeExtension.expression.type === 'Identifier' &&
+                    typeNames.includes(typeExtensionName)) {
+                    typeExtension.expression.name = `FlexProps`;
+                }
+            }
+        });
+    });
+    // Transform `spacing` key that are in type interface declaration references
+    // e.g. `interface CustomProps extends StackProps {
+    // spacing: SystemPropValues['space']
+    // }`
+    // becomes `interface CustomProps extends FlexProps {
+    // gap: FlexProps['gap']
+    // }`
+    const spacingName = ['spacing'];
+    // Transform `spacing` key that is in type interface
+    // e.g. `spacing: SystemPropValues['space']`
+    // becomes `gap: FlexProps['gap']`
+    root.find(j.TSLiteralType, { type: 'TSLiteralType' }).forEach(nodePath => {
+        if (nodePath.node.literal.type === 'StringLiteral') {
+            if (spacingName.includes(nodePath.node.literal.value)) {
+                nodePath.node.literal.value = 'gap';
+            }
+        }
+    });
+    // Transforms `as` prop Stack, HStack or VStack values to `Flex`
+    // e.g. <Card as={Stack} spacing="s" />
+    // becomes <Card as={Flex} gap="s" />
+    root.find(j.JSXOpeningElement, { type: 'JSXOpeningElement' }).forEach(nodePath => {
+        var _a, _b;
+        let isCastAsStack = false;
+        (_a = nodePath.node.attributes) === null || _a === void 0 ? void 0 : _a.forEach(attr => {
+            var _a;
+            if (attr.type === 'JSXAttribute') {
+                if (attr.name.name === 'as') {
+                    if (((_a = attr.value) === null || _a === void 0 ? void 0 : _a.type) === 'JSXExpressionContainer') {
+                        if (attr.value.expression.type === 'Identifier') {
+                            if (stackImportNames.includes(attr.value.expression.name)) {
+                                isCastAsStack = true;
+                                attr.value.expression.name = 'Flex';
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        if (isCastAsStack) {
+            (_b = nodePath.node.attributes) === null || _b === void 0 ? void 0 : _b.forEach(attr => {
+                if (attr.type === 'JSXAttribute') {
+                    if (attr.name.name === 'spacing') {
+                        attr.name.name = 'gap';
+                    }
+                }
+            });
+        }
+    });
+    // Transform Stack, HStack and VStack JSXElements
+    // Transform `<Stack spacing="l">` to `<Flex gap="l">`
+    // Transform `<Stack shouldWrapChildren>` to `<Flex >`
+    root.find(j.JSXOpeningElement).forEach(nodePath => {
+        var _a;
+        if (nodePath.node.type === 'JSXOpeningElement') {
+            if (nodePath.node.name.type === 'JSXIdentifier') {
+                if (importedComponentNames.includes(nodePath.node.name.name)) {
+                    (_a = nodePath.node.attributes) === null || _a === void 0 ? void 0 : _a.forEach(path => {
+                        if (path.type === 'JSXAttribute') {
+                            if (path.name.name === 'spacing') {
+                                path.name.name = 'gap';
+                            }
+                            if (path.name.name === 'shouldWrapChildren') {
+                                path.name.name = '';
+                            }
+                        }
+                    });
+                }
+            }
+        }
+    });
+    // Transform spacing on JSXMemberExpression
+    // Transform `<Stack.Item spacing="l">` to `<Flex.Item gap="l">`
+    root.find(j.JSXOpeningElement).forEach(nodePath => {
+        var _a;
+        if (nodePath.node.type === 'JSXOpeningElement') {
+            if (nodePath.node.name.type === 'JSXMemberExpression') {
+                if (nodePath.node.name.object.type === 'JSXIdentifier') {
+                    const nodePathName = nodePath.node.name.object.name;
+                    if (altImportSpecifier.includes(nodePathName)) {
+                        if (nodePath.node.name.property.name === 'List' ||
+                            nodePath.node.name.property.name === 'Item') {
+                            (_a = nodePath.node.attributes) === null || _a === void 0 ? void 0 : _a.forEach(path => {
+                                if (path.type === 'JSXAttribute') {
+                                    if (path.name.name === 'spacing') {
+                                        path.name.name = 'gap';
+                                    }
+                                }
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    });
+    // Transform styled compoents
+    // e.g. `const StyledStack = styled(Stack)({});`
+    // becomes `const StyledStack = styled(Flex)({});`
+    root.find(j.VariableDeclarator).forEach(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' &&
+            stackImportNames.includes(nodePath.value.init.callee.arguments[0].name)) {
+            nodePath.value.init.callee.arguments[0].name = 'Flex';
+        }
+    });
+    // Transform Stack JSXElements
+    // Transform `<Stack>` to `<Flex>`
+    root.find(j.JSXIdentifier, { name: 'Stack' }).forEach(nodePath => {
+        nodePath.node.name = 'Flex';
+    });
+    // Transform Stack JSXElements
+    // e.g. `<HStack>` becomes `<Flex>`
+    root.find(j.JSXIdentifier, { name: 'HStack' }).forEach(nodePath => {
+        nodePath.node.name = 'Flex';
+    });
+    // Creating new JSXAttribute to push in attribute array for VStack
+    // Since we're replacing VStack with Flex, it will need a
+    // flexDirection="column" added
+    const newVStackProp = {
+        type: 'JSXAttribute',
+        name: { type: 'JSXIdentifier', name: 'flexDirection' },
+        value: { type: 'Literal', value: 'column' },
+    };
+    root
+        .find(j.JSXOpeningElement, { name: { type: 'JSXIdentifier', name: 'VStack' } })
+        .forEach(nodePath => {
+        var _a;
+        (_a = nodePath.node.attributes) === null || _a === void 0 ? void 0 : _a.push(newVStackProp);
+    });
+    // Transform VStack JSXElements
+    // e.g. `<VStack>` becomes `<Flex>`
+    root.find(j.JSXIdentifier, { name: 'VStack' }).forEach(nodePath => {
+        nodePath.node.name = 'Flex';
+    });
+    return root.toSource();
+}

package/dist/es6/v9/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/v9/index.d.ts.map

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

package/dist/es6/v9/index.js

@@ -0,0 +1,16 @@
+import deprecateStack from './deprecateStack';
+import promoteToast from './promoteToast';
+import compoundToast from './compoundToast';
+import promoteUseThemedRing from './promoteUseThemedRing';
+const transform = (file, api, options) => {
+    // These will run in order. If your transform depends on others, place yours after dependent transforms
+    const fixes = [
+        // add codemods here
+        deprecateStack,
+        compoundToast,
+        promoteToast,
+        promoteUseThemedRing,
+    ];
+    return fixes.reduce((source, fix) => fix({ ...file, source }, api, options), file.source);
+};
+export default transform;

package/dist/es6/v9/promoteToast.d.ts

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

package/dist/es6/v9/promoteToast.d.ts.map

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

package/dist/es6/v9/promoteToast.js

@@ -0,0 +1,56 @@
+const transform = (file, api) => {
+    const j = api.jscodeshift;
+    const root = j(file.source);
+    const toastSpecifiers = [];
+    const foundImport = [];
+    root
+        .find(j.ImportDeclaration, {
+        source: { value: (value) => value.includes('@workday/canvas-kit-labs-react') },
+    })
+        .forEach(nodePath => {
+        var _a;
+        nodePath.value.specifiers = (_a = nodePath.value.specifiers) === null || _a === void 0 ? void 0 : _a.filter(specifier => {
+            if (specifier.type === 'ImportSpecifier' &&
+                specifier.local &&
+                specifier.imported.name === 'Toast') {
+                toastSpecifiers.push({
+                    importedName: specifier.imported.name,
+                    name: specifier.local.name,
+                });
+                return false;
+            }
+            return true;
+        });
+        if (toastSpecifiers.length) {
+            foundImport.push(nodePath);
+        }
+    });
+    const existingToastImports = root.find(j.ImportDeclaration, {
+        source: { value: '@workday/canvas-kit-react/toast' },
+    });
+    const mapToSpecifiers = (specifier) => {
+        return j.importSpecifier(j.identifier(specifier.importedName), specifier.name ? j.identifier(specifier.name) : undefined);
+    };
+    // add to existing import
+    if (existingToastImports.length) {
+        existingToastImports.forEach(nodePath => {
+            var _a;
+            nodePath.value.specifiers = (_a = nodePath.value.specifiers) === null || _a === void 0 ? void 0 : _a.concat(toastSpecifiers.map(mapToSpecifiers));
+        });
+    }
+    else {
+        // create new import
+        if (foundImport.length) {
+            foundImport[0].insertBefore(j.importDeclaration(toastSpecifiers.map(mapToSpecifiers), j.stringLiteral('@workday/canvas-kit-react/toast')));
+        }
+    }
+    foundImport.forEach(importPath => {
+        var _a;
+        if (!((_a = importPath.value.specifiers) === null || _a === void 0 ? void 0 : _a.length) ||
+            importPath.value.source.value === '@workday/canvas-kit-labs-react/toast') {
+            importPath.prune();
+        }
+    });
+    return root.toSource();
+};
+export default transform;

package/dist/es6/v9/promoteUseThemedRing.d.ts

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

package/dist/es6/v9/promoteUseThemedRing.d.ts.map

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

package/dist/es6/v9/promoteUseThemedRing.js

@@ -0,0 +1,56 @@
+const transform = (file, api) => {
+    const j = api.jscodeshift;
+    const root = j(file.source);
+    const common = [];
+    const foundImport = [];
+    root
+        .find(j.ImportDeclaration, {
+        source: { value: (value) => value.includes('@workday/canvas-kit-labs-react') },
+    })
+        .forEach(nodePath => {
+        var _a;
+        nodePath.value.specifiers = (_a = nodePath.value.specifiers) === null || _a === void 0 ? void 0 : _a.filter(specifier => {
+            if (specifier.type === 'ImportSpecifier' &&
+                specifier.local &&
+                specifier.imported.name === 'useThemedRing') {
+                common.push({
+                    importedName: specifier.imported.name,
+                    name: specifier.local.name,
+                });
+                return false;
+            }
+            return true;
+        });
+        if (common.length) {
+            foundImport.push(nodePath);
+        }
+    });
+    const existingCommonImports = root.find(j.ImportDeclaration, {
+        source: { value: '@workday/canvas-kit-react/common' },
+    });
+    const mapToSpecifiers = (specifier) => {
+        return j.importSpecifier(j.identifier(specifier.importedName), specifier.name ? j.identifier(specifier.name) : undefined);
+    };
+    // add to existing import
+    if (existingCommonImports.length) {
+        existingCommonImports.forEach(nodePath => {
+            var _a;
+            nodePath.value.specifiers = (_a = nodePath.value.specifiers) === null || _a === void 0 ? void 0 : _a.concat(common.map(mapToSpecifiers));
+        });
+    }
+    else {
+        // create new import
+        if (foundImport.length) {
+            foundImport[0].insertBefore(j.importDeclaration(common.map(mapToSpecifiers), j.stringLiteral('@workday/canvas-kit-react/common')));
+        }
+    }
+    foundImport.forEach(importPath => {
+        var _a;
+        if (!((_a = importPath.value.specifiers) === null || _a === void 0 ? void 0 : _a.length) ||
+            importPath.value.source.value === '@workday/canvas-kit-labs-react/common') {
+            importPath.prune();
+        }
+    });
+    return root.toSource();
+};
+export default transform;

package/index.js

@@ -4,9 +4,28 @@
 const {spawn} = require('child_process');
 const chalk = require('chalk');
 
-const {_: commands, path} = require('yargs')
+const {_: commands, path, ignoreConfig, ignorePattern, verbose} = require('yargs')
   .scriptName('canvas-kit-codemod')
   .usage(chalk.bold.blueBright('$0 <transform> [path]'))
+  .options({
+    'ignore-config': {
+      type: 'string',
+      describe:
+        'Ignore files if they match patterns sourced from a configuration file (e.g. a .gitignore)',
+      default: '',
+    },
+    'ignore-pattern': {
+      type: 'string',
+      describe: 'Ignore files that match a provided glob expression (e.g. **/dist/**)',
+      default: '**/node_modules/**',
+    },
+    verbose: {
+      type: 'number',
+      describe: 'Show more information about the transform process',
+      default: 0,
+      choices: [0, 1, 2],
+    },
+  })
   .command('v5 [path]', chalk.gray('Canvas Kit v4 > v5 migration transform'), yargs => {
     yargs.positional('path', {
       type: 'string',
@@ -14,14 +33,28 @@ const {_: commands, path} = require('yargs')
       describe: chalk.gray('The path to execute the transform in (recursively).'),
     });
   })
-  .command('v6 [path]', chalk.gray('Canvas Kit v5 > v6 migration transform'), yargs => {
+  .command('v6 [path]', chalk.gray('Canvas Kit v5 > v6 upgrade transform'), yargs => {
+    yargs.positional('path', {
+      type: 'string',
+      default: '.',
+      describe: chalk.gray('The path to execute the transform in (recursively).'),
+    });
+  })
+  .command('v7 [path]', chalk.gray('Canvas Kit v6 > v7 upgrade transform'), yargs => {
+    yargs.positional('path', {
+      type: 'string',
+      default: '.',
+      describe: chalk.gray('The path to execute the transform in (recursively).'),
+    });
+  })
+  .command('v8 [path]', chalk.gray('Canvas Kit v7 > v8 upgrade transform'), yargs => {
     yargs.positional('path', {
       type: 'string',
       default: '.',
       describe: chalk.gray('The path to execute the transform in (recursively).'),
     });
   })
-  .command('v7 [path]', chalk.gray('Canvas Kit v6 > v7 migration transform'), yargs => {
+  .command('v9 [path]', chalk.gray('Canvas Kit v8 > v9 upgrade transform'), yargs => {
     yargs.positional('path', {
       type: 'string',
       default: '.',
@@ -46,10 +79,12 @@ const {_: commands, path} = require('yargs')
   .help().argv;
 
 const transform = commands[0];
-console.log(transform, path);
+// Only add an ignore-config if one is provided
+const ignoreConfigArg = ignoreConfig ? `--ignore-config=${ignoreConfig}` : '';
+console.log(ignorePattern);
 
 console.log(chalk.blueBright(`\nApplying ${transform} transform to '${path}'\n`));
-const args = `-t ${__dirname}/dist/es6/${transform} ${path} --parser tsx --extensions js,jsx,ts,tsx`.split(
+const args = `-t ${__dirname}/dist/es6/${transform} ${path} --parser tsx --extensions js,jsx,ts,tsx ${ignoreConfigArg} --ignore-pattern=${ignorePattern} --verbose=${verbose}`.split(
   ' '
 );
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "@workday/canvas-kit-codemod",
   "author": "Workday, Inc. (https://www.workday.com)",
   "license": "Apache-2.0",
-  "version": "7.1.4",
+  "version": "7.2.0-427-next.2+2c79134a",
   "description": "A collection of codemods for use on Workday Canvas Kit packages.",
   "main": "dist/es6/index.js",
   "sideEffects": false,
@@ -43,5 +43,5 @@
     "test": "TZ=UTC jest -c ../../jest.config.js",
     "typecheck:src": "tsc -p . --noEmit --incremental false"
   },
-  "gitHead": "6c20e6b9755afa86a865f4e90c24a4a52ea9e481"
+  "gitHead": "2c79134aa48ef0efde9cdf883b529b8157337a28"
 }