@workday/canvas-kit-styling-transform 10.3.2 → 10.3.4

package/dist/commonjs/lib/utils/handleCreateStencil.js

@@ -1,203 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleCreateStencil = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const canvas_kit_styling_1 = require("@workday/canvas-kit-styling");
-const getVarName_1 = require("./getVarName");
-const makeEmotionSafe_1 = require("./makeEmotionSafe");
-const parseObjectToStaticValue_1 = require("./parseObjectToStaticValue");
-const createStyleObjectNode_1 = require("./createStyleObjectNode");
-const parseNodeToStaticValue_1 = require("./parseNodeToStaticValue");
-const isImportedFromStyling_1 = require("./isImportedFromStyling");
-/**
- * Handle all arguments of the CallExpression `createStencil()`
- */
-const handleCreateStencil = (node, context) => {
-    const { checker, prefix, variables } = context;
-    /**
-     * This will match whenever a `createStencil()` call expression is encountered. It will loop
-     * over all the config to extract variables and styles.
-     *
-     */
-    if (typescript_1.default.isCallExpression(node) &&
-        typescript_1.default.isIdentifier(node.expression) &&
-        node.expression.text === 'createStencil' &&
-        isImportedFromStyling_1.isImportedFromStyling(node.expression, checker)) {
-        const config = node.arguments[0];
-        /**
-         * Stencils can define variables that are used in style object functions. Inside those
-         * functions, the full variable name is not used, but rather destructured. We'll create
-         * temporary local variables for these style object functions.
-         *
-         * For example:
-         * ```ts
-         * const myStencil = createStencil({
-         *   vars: { color: 'red' },
-         *   base: ({color}) => ({
-         *     color: color
-         *   })
-         * })
-         * ```
-         */
-        const tempVariables = {};
-        // We need to keep track of stencil variables and values to automatically merge into the base
-        // styles
-        const stencilVariables = {};
-        // Stencil name is the variable name
-        const stencilName = canvas_kit_styling_1.slugify(getVarName_1.getVarName(node)).replace('-stencil', '');
-        if (typescript_1.default.isObjectLiteralExpression(config)) {
-            // get variables first
-            const varsConfig = config.properties.find(property => {
-                return (property.name &&
-                    typescript_1.default.isIdentifier(property.name) &&
-                    property.name.text === 'vars' &&
-                    typescript_1.default.isPropertyAssignment(property));
-            });
-            function extractVariables(node) {
-                if (typescript_1.default.isPropertyAssignment(node) && typescript_1.default.isIdentifier(node.name)) {
-                    if (typescript_1.default.isObjectLiteralExpression(node.initializer)) {
-                        return node.initializer.properties.map(extractVariables);
-                    }
-                    const varName = `${stencilName}-${makeEmotionSafe_1.makeEmotionSafe(node.name.text)}`;
-                    const varValue = `--${prefix}-${varName}`;
-                    variables[`${varName}`] = varValue;
-                    variables[makeEmotionSafe_1.makeEmotionSafe(node.name.text)] = varValue;
-                    tempVariables[makeEmotionSafe_1.makeEmotionSafe(node.name.text)] = varValue;
-                    // Evaluate the variable defaults
-                    stencilVariables[varValue] = parseNodeToStaticValue_1.parseNodeToStaticValue(node.initializer, context);
-                }
-            }
-            if (varsConfig && typescript_1.default.isObjectLiteralExpression(varsConfig.initializer)) {
-                varsConfig.initializer.properties.forEach(variable => {
-                    extractVariables(variable);
-                });
-            }
-            config.properties.forEach((property, index, properties) => {
-                if (property.name && typescript_1.default.isIdentifier(property.name)) {
-                    // base config object
-                    if (property.name.text === 'base') {
-                        const styleObj = parseStyleBlock(property, context);
-                        if (styleObj) {
-                            // The `as any` are necessary because the properties are readonly, even though they
-                            // can be changed in transformers.
-                            const initializer = createStyleObjectNode_1.createStyleObjectNode({
-                                ...stencilVariables,
-                                ...styleObj,
-                            });
-                            // We cast as any because TypeScript says these are readonly, but we're in a transform
-                            initializer.parent = property;
-                            properties[index] = typescript_1.default.factory.createPropertyAssignment(property.name, initializer);
-                        }
-                    }
-                    // modifiers config object
-                    if (property.name.text === 'modifiers' &&
-                        typescript_1.default.isPropertyAssignment(property) &&
-                        typescript_1.default.isObjectLiteralExpression(property.initializer)) {
-                        property.initializer.properties.forEach(modifierProperty => {
-                            if (modifierProperty.name &&
-                                typescript_1.default.isIdentifier(modifierProperty.name) &&
-                                typescript_1.default.isPropertyAssignment(modifierProperty) &&
-                                typescript_1.default.isObjectLiteralExpression(modifierProperty.initializer)) {
-                                modifierProperty.initializer.properties.forEach((modifier, index, modifiers) => {
-                                    const styleObj = parseStyleBlock(modifier, context);
-                                    if (styleObj && modifier.name) {
-                                        // The `as any` are necessary because the properties are readonly, even though they
-                                        // can be changed in transformers.
-                                        const initializer = createStyleObjectNode_1.createStyleObjectNode(styleObj);
-                                        // // We cast as any because TypeScript says these are readonly, but we're in a transform
-                                        initializer.parent = modifier;
-                                        modifiers[index] = typescript_1.default.factory.createPropertyAssignment(modifier.name, initializer);
-                                    }
-                                });
-                            }
-                        });
-                    }
-                    // compound config array
-                    if (property.name.text === 'compound' &&
-                        typescript_1.default.isPropertyAssignment(property) &&
-                        typescript_1.default.isArrayLiteralExpression(property.initializer)) {
-                        property.initializer.elements.forEach(element => {
-                            if (typescript_1.default.isObjectLiteralExpression(element)) {
-                                element.properties.forEach((compoundProperty, index, compoundProperties) => {
-                                    // styles key
-                                    if (compoundProperty.name &&
-                                        typescript_1.default.isIdentifier(compoundProperty.name) &&
-                                        compoundProperty.name.text === 'styles') {
-                                        const styleObj = parseStyleBlock(compoundProperty, context);
-                                        if (styleObj) {
-                                            // The `as any` are necessary because the properties are readonly, even though they
-                                            // can be changed in transformers.
-                                            const initializer = createStyleObjectNode_1.createStyleObjectNode(styleObj);
-                                            // We cast as any because TypeScript says these are readonly, but we're in a transform
-                                            initializer.parent = compoundProperty;
-                                            compoundProperties[index] = typescript_1.default.factory.createPropertyAssignment(compoundProperty.name, initializer);
-                                        }
-                                    }
-                                });
-                            }
-                        });
-                    }
-                }
-            });
-        }
-        // remove all our temp variables
-        // eslint-disable-next-line guard-for-in
-        for (const key in tempVariables) {
-            delete variables[key];
-        }
-        // arguments are readonly, but we're in a transform
-        node.arguments[1] = typescript_1.default.factory.createStringLiteral(stencilName);
-        node.arguments[1].parent = node;
-        return node;
-    }
-    return;
-};
-exports.handleCreateStencil = handleCreateStencil;
-/**
- * A style block is a `base`, `modifier`, or `compoundModifier` style block. It could be an ObjectLiteralExpression,
- * an ArrowFunction, MethodDeclaration, etc.
- */
-function parseStyleBlock(property, context) {
-    let styleObj;
-    if (typescript_1.default.isPropertyAssignment(property)) {
-        if (typescript_1.default.isObjectLiteralExpression(property.initializer)) {
-            styleObj = parseObjectToStaticValue_1.parseObjectToStaticValue(property.initializer, context);
-        }
-        if (isFunctionLikeDeclaration(property.initializer)) {
-            const returnNode = getReturnStatement(property.initializer);
-            if (returnNode) {
-                styleObj = parseObjectToStaticValue_1.parseObjectToStaticValue(returnNode, context);
-            }
-        }
-    }
-    if (isFunctionLikeDeclaration(property)) {
-        const returnNode = getReturnStatement(property);
-        if (returnNode) {
-            styleObj = parseObjectToStaticValue_1.parseObjectToStaticValue(returnNode, context);
-        }
-    }
-    return styleObj;
-}
-function getReturnStatement(node) {
-    if (node.body && typescript_1.default.isParenthesizedExpression(node.body)) {
-        return node.body.expression;
-    }
-    if (node.body && typescript_1.default.isBlock(node.body)) {
-        let returnNode;
-        // look for the return statement. It must be a top-level statement in the block
-        node.body.statements.forEach(statement => {
-            // () => { return {} }
-            if (typescript_1.default.isReturnStatement(statement)) {
-                returnNode = statement.expression;
-            }
-        });
-        return returnNode;
-    }
-    return undefined;
-}
-function isFunctionLikeDeclaration(node) {
-    return node.hasOwnProperty('body');
-}

package/dist/commonjs/lib/utils/handleCreateStyles.d.ts

@@ -1,3 +0,0 @@
-import { NodeTransformer } from './types';
-export declare const handleCreateStyles: NodeTransformer;
-//# sourceMappingURL=handleCreateStyles.d.ts.map

package/dist/commonjs/lib/utils/handleCreateStyles.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleCreateStyles.d.ts","sourceRoot":"","sources":["../../../../lib/utils/handleCreateStyles.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,eAAe,EAAC,MAAM,SAAS,CAAC;AAGxC,eAAO,MAAM,kBAAkB,EAAE,eA4GhC,CAAC"}

package/dist/commonjs/lib/utils/handleCreateStyles.js

@@ -1,110 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleCreateStyles = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const parseObjectToStaticValue_1 = require("./parseObjectToStaticValue");
-const createStyleObjectNode_1 = require("./createStyleObjectNode");
-const isImportedFromStyling_1 = require("./isImportedFromStyling");
-const handleCreateStyles = (node, context) => {
-    const { checker } = context;
-    /**
-     * Check if the node is a call expression that looks like:
-     *
-     * ```ts
-     * createStyles({
-     *   // properties
-     * })
-     * ```
-     *
-     * It will also make sure the `createStyles` function was imported from
-     * `@workday/canvas-kit-styling` to ensure we don't rewrite the AST of code we don't own.
-     *
-     * This transformation will pre-serialize the style objects and turn them into strings for
-     * faster runtime processing in Emotion. The following is an example of the transformation.
-     *
-     * ```ts
-     * // before transformation
-     * const myStyles = createStyles({
-     *   fontSize: '1rem'
-     * })
-     *
-     * // after transformation
-     * const myStyles = createStyles({
-     *   name: 'abc123',
-     *   styles: 'font-size: 1rem;'
-     * })
-     * ```
-     *
-     * The after transformation already serialized the styles and goes through a shortcut process
-     * in `@emotion/css` where only the Emotion cache is checked and styles are inserted if the
-     * cache key wasn't found.
-     */
-    if (typescript_1.default.isCallExpression(node) &&
-        typescript_1.default.isIdentifier(node.expression) &&
-        node.expression.text === 'createStyles' &&
-        isImportedFromStyling_1.isImportedFromStyling(node.expression, checker) &&
-        node.arguments.length > 0) {
-        const newArguments = [...node.arguments].map(arg => {
-            // An `ObjectLiteralExpression` is an object like `{foo:'bar'}`:
-            // https://ts-ast-viewer.com/#code/MYewdgzgLgBFCmBbADjAvDA3gKBjAZiCAFwwDkARgIYBOZ2AvkA
-            if (typescript_1.default.isObjectLiteralExpression(arg)) {
-                const styleObj = parseObjectToStaticValue_1.parseObjectToStaticValue(arg, context);
-                return createStyleObjectNode_1.createStyleObjectNode(styleObj);
-            }
-            // An Identifier is a variable. It could come from anywhere - imports, earlier
-            // assignments, etc. The easiest thing to do is to ask the TypeScript type checker what
-            // the type representation is and go from there.
-            if (typescript_1.default.isIdentifier(arg)) {
-                const type = checker.getTypeAtLocation(arg);
-                // `createStyles` accepts strings as class names. If the class name is
-                if (type.isStringLiteral() || type.getFlags() & typescript_1.default.TypeFlags.String) {
-                    return arg;
-                }
-                // The type must be a object
-                const styleObj = parseObjectToStaticValue_1.parseStyleObjFromType(type, context);
-                return createStyleObjectNode_1.createStyleObjectNode(styleObj);
-            }
-            return arg;
-        });
-        newArguments.forEach(argument => {
-            // TypeScript isn't expecting us to mutate arguments arguments and when emitting will
-            // try to do something where it checks the `parent` node of the argument. Using
-            // `ts.factory.create*`, the `parent` is `undefined` and this check will throw an error.
-            // In order to get past this error, we manually update the `parent` node of each
-            // argument to reference the existing call expression. This allows TypeScript to fully
-            // type check and/or emit.
-            argument.parent = node;
-        });
-        /**
-         * We're not supposed to mutate arguments since it is supposed to be read-only. But, if I
-         * return a new callExpression, there is no parent and it is no longer linked to the
-         * import module. This causes incorrect code when the module export type is `commonjs`.
-         * For example:
-         *
-         * ```ts
-         * // with new callExpression
-         * const canvas_kit_styling_1 = require(...)
-         *
-         * createStyles({...})
-         *
-         * // if we instead mutate arguments
-         * const canvas_kit_styling_1 = require(...)
-         *
-         * canvas_kit_styling_1.createStyles({...})
-         * ```
-         *
-         * My best guess as to why it fails when creating a new callExpression is the node's
-         * symbol declaration link gets lost. TypeScript then has no idea `createStyles` comes
-         * from an `ImportDeclaration` declaration node and when emitting `commonjs`, it doesn't
-         * prefix with the `canvas_kit_styling_1`. This is hacky, but the only thing that works
-         * correctly.
-         */
-        node.arguments = newArguments;
-        return node;
-    }
-    return;
-};
-exports.handleCreateStyles = handleCreateStyles;

package/dist/commonjs/lib/utils/handleCreateVars.d.ts

@@ -1,3 +0,0 @@
-import { NodeTransformer } from './types';
-export declare const handleCreateVars: NodeTransformer;
-//# sourceMappingURL=handleCreateVars.d.ts.map

package/dist/commonjs/lib/utils/handleCreateVars.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleCreateVars.d.ts","sourceRoot":"","sources":["../../../../lib/utils/handleCreateVars.ts"],"names":[],"mappings":"AAMA,OAAO,EAAC,eAAe,EAAC,MAAM,SAAS,CAAC;AAExC,eAAO,MAAM,gBAAgB,EAAE,eA2C9B,CAAC"}

package/dist/commonjs/lib/utils/handleCreateVars.js

@@ -1,34 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleCreateVars = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const canvas_kit_styling_1 = require("@workday/canvas-kit-styling");
-const getVarName_1 = require("./getVarName");
-const makeEmotionSafe_1 = require("./makeEmotionSafe");
-const handleCreateVars = (node, { prefix, variables }) => {
-    /**
-     * This will create a variable
-     */
-    if (typescript_1.default.isCallExpression(node) &&
-        typescript_1.default.isIdentifier(node.expression) &&
-        node.expression.text === 'createVars') {
-        const id = canvas_kit_styling_1.slugify(getVarName_1.getVarName(node)).replace('-vars', '');
-        const vars = node.arguments
-            .map(arg => typescript_1.default.isStringLiteral(arg) && arg.text)
-            .filter(Boolean);
-        vars.forEach(v => {
-            variables[`${id}-${makeEmotionSafe_1.makeEmotionSafe(v)}`] = `--${prefix}-${id}-${makeEmotionSafe_1.makeEmotionSafe(v)}`;
-        });
-        return typescript_1.default.factory.createCallExpression(node.expression, [], [
-            typescript_1.default.factory.createObjectLiteralExpression([
-                typescript_1.default.factory.createPropertyAssignment(typescript_1.default.factory.createIdentifier('id'), typescript_1.default.factory.createStringLiteral(`${prefix}-${id}`)),
-                typescript_1.default.factory.createPropertyAssignment(typescript_1.default.factory.createIdentifier('args'), typescript_1.default.factory.createArrayLiteralExpression(vars.map(val => typescript_1.default.factory.createStringLiteral(val)), false)),
-            ], false),
-        ]);
-    }
-    return;
-};
-exports.handleCreateVars = handleCreateVars;

package/dist/commonjs/lib/utils/handleCssVar.d.ts

@@ -1,12 +0,0 @@
-import { NodeTransformer } from './types';
-/**
- * Converts `cssVar` to a `TemplateExpression` with each argument as a span
- *
- * - `cssVar('--foo')` => `\`var(${'--foo'})\``
- * - `cssVar('--foo', 'fallback')` => `\`var(${'--foo'}, ${'fallback'})\``
- *
- * The value parser will figure out what to do from there. We don't have access to variables at this
- * point, so we forward CallExpression arguments in ways the value parser understands.
- */
-export declare const handleCssVar: NodeTransformer;
-//# sourceMappingURL=handleCssVar.d.ts.map

package/dist/commonjs/lib/utils/handleCssVar.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleCssVar.d.ts","sourceRoot":"","sources":["../../../../lib/utils/handleCssVar.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,eAAe,EAAC,MAAM,SAAS,CAAC;AAExC;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,EAAE,eAoB1B,CAAC"}

package/dist/commonjs/lib/utils/handleCssVar.js

@@ -1,33 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleCssVar = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-/**
- * Converts `cssVar` to a `TemplateExpression` with each argument as a span
- *
- * - `cssVar('--foo')` => `\`var(${'--foo'})\``
- * - `cssVar('--foo', 'fallback')` => `\`var(${'--foo'}, ${'fallback'})\``
- *
- * The value parser will figure out what to do from there. We don't have access to variables at this
- * point, so we forward CallExpression arguments in ways the value parser understands.
- */
-const handleCssVar = node => {
-    // cssVar(a)
-    // cssVar(a, b)
-    if (typescript_1.default.isCallExpression(node) &&
-        typescript_1.default.isIdentifier(node.expression) &&
-        node.expression.text === 'cssVar') {
-        if (node.arguments.length === 1) {
-            return node.arguments[0];
-        }
-        return typescript_1.default.factory.createTemplateExpression(typescript_1.default.factory.createTemplateHead('var('), [
-            typescript_1.default.factory.createTemplateSpan(node.arguments[0], typescript_1.default.factory.createTemplateMiddle(', ')),
-            typescript_1.default.factory.createTemplateSpan(node.arguments[1], typescript_1.default.factory.createTemplateTail(')')),
-        ]);
-    }
-    return;
-};
-exports.handleCssVar = handleCssVar;

package/dist/commonjs/lib/utils/handleFocusRing.d.ts

@@ -1,3 +0,0 @@
-import { NodeTransformer } from './types';
-export declare const handleFocusRing: NodeTransformer;
-//# sourceMappingURL=handleFocusRing.d.ts.map

package/dist/commonjs/lib/utils/handleFocusRing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleFocusRing.d.ts","sourceRoot":"","sources":["../../../../lib/utils/handleFocusRing.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,eAAe,EAAC,MAAM,SAAS,CAAC;AAGxC,eAAO,MAAM,eAAe,EAAE,eAwG7B,CAAC"}

package/dist/commonjs/lib/utils/handleFocusRing.js

@@ -1,83 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleFocusRing = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const canvas_tokens_web_1 = require("@workday/canvas-tokens-web");
-const parseNodeToStaticValue_1 = require("./parseNodeToStaticValue");
-const handleFocusRing = (node, context) => {
-    // { ...focusRing() }
-    /**
-     * A spread assignment looks like:
-     *
-     * ```ts
-     * {
-     *   ...styles
-     * }
-     * ```
-     *
-     * https://ts-ast-viewer.com/#code/MYewdgzgLgBFCmBbADjAvDA3gMxCAXDAOQBGAhgE5EC+AUKJLAigEzpYB0Xzy1QA
-     */
-    if (typescript_1.default.isSpreadAssignment(node)) {
-        // Detect `focusRing` calls. This is temporary until we figure out a better way to do focus
-        // rings that doesn't require a special entry in the transform function.
-        //
-        // TODO: implement a fully working type resolver for CSS variables or remove support for them an
-        // remove all uses of `focusRing` from new styling code
-        if (typescript_1.default.isCallExpression(node.expression) &&
-            typescript_1.default.isIdentifier(node.expression.expression) &&
-            node.expression.expression.text === 'focusRing') {
-            const argumentObject = node.expression.arguments[0];
-            // defaults
-            const defaults = {
-                width: typescript_1.default.factory.createStringLiteral('2px'),
-                separation: typescript_1.default.factory.createStringLiteral('0px'),
-                inset: typescript_1.default.factory.createIdentifier('undefined'),
-                innerColor: typescript_1.default.factory.createStringLiteral(canvas_tokens_web_1.base.frenchVanilla100),
-                outerColor: typescript_1.default.factory.createStringLiteral(canvas_tokens_web_1.brand.common.focusOutline),
-            };
-            if (argumentObject && typescript_1.default.isObjectLiteralExpression(argumentObject)) {
-                argumentObject.properties.forEach(property => {
-                    if (typescript_1.default.isPropertyAssignment(property) && typescript_1.default.isIdentifier(property.name)) {
-                        defaults[property.name.text] = property.initializer;
-                    }
-                });
-            }
-            const inset = parseNodeToStaticValue_1.parseNodeToStaticValue(defaults.inset, context);
-            let boxShadow;
-            switch (inset) {
-                case 'outer':
-                    boxShadow = createTemplateExpression('inset 0 0 0 ', defaults.separation, ' ', defaults.outerColor, ' inset 0 0 0 calc(', defaults.width, ' + ', defaults.separation, ') ', defaults.innerColor);
-                    break;
-                case 'inner':
-                    boxShadow = createTemplateExpression('inset 0 0 0 ', defaults.separation, ' ', defaults.innerColor, ', 0 0 0 ', defaults.width, ' ', defaults.outerColor);
-                    break;
-                default:
-                    boxShadow = createTemplateExpression('0 0 0 ', defaults.separation, ' ', defaults.innerColor, ', 0 0 0 calc(', defaults.width, ' + ', defaults.separation, ') ', defaults.outerColor);
-                    break;
-            }
-            return typescript_1.default.factory.createSpreadAssignment(typescript_1.default.factory.createObjectLiteralExpression([
-                typescript_1.default.factory.createPropertyAssignment(typescript_1.default.factory.createIdentifier('boxShadow'), boxShadow),
-            ], false));
-        }
-    }
-    return;
-};
-exports.handleFocusRing = handleFocusRing;
-function createTemplateExpression(head, ...args) {
-    const headNode = typescript_1.default.factory.createTemplateHead(head);
-    const spanNodes = args.reduce((result, value, index) => {
-        if (typeof value !== 'string') {
-            const literal = index === args.length - 1
-                ? typescript_1.default.factory.createTemplateTail('')
-                : index === args.length - 2
-                    ? typescript_1.default.factory.createTemplateTail(args[index + 1])
-                    : typescript_1.default.factory.createTemplateMiddle(args[index + 1]);
-            result.push(typescript_1.default.factory.createTemplateSpan(value, literal));
-        }
-        return result;
-    }, []);
-    return typescript_1.default.factory.createTemplateExpression(headNode, spanNodes);
-}

package/dist/commonjs/lib/utils/handleKeyframes.d.ts

@@ -1,3 +0,0 @@
-import { NodeTransformer } from './types';
-export declare const handleKeyframes: NodeTransformer;
-//# sourceMappingURL=handleKeyframes.d.ts.map

package/dist/commonjs/lib/utils/handleKeyframes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleKeyframes.d.ts","sourceRoot":"","sources":["../../../../lib/utils/handleKeyframes.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,eAAe,EAAC,MAAM,SAAS,CAAC;AAOxC,eAAO,MAAM,eAAe,EAAE,eA+C7B,CAAC"}

package/dist/commonjs/lib/utils/handleKeyframes.js

@@ -1,47 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleKeyframes = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const parseNodeToStaticValue_1 = require("./parseNodeToStaticValue");
-const getVarName_1 = require("./getVarName");
-const createStyleObjectNode_1 = require("./createStyleObjectNode");
-const isImportedFromStyling_1 = require("./isImportedFromStyling");
-const parseObjectToStaticValue_1 = require("./parseObjectToStaticValue");
-const handleKeyframes = (node, context) => {
-    const { checker, keyframes } = context;
-    // keyframes`css`
-    if (typescript_1.default.isTaggedTemplateExpression(node) &&
-        typescript_1.default.isIdentifier(node.tag) &&
-        node.tag.text === 'keyframes' &&
-        isImportedFromStyling_1.isImportedFromStyling(node.tag, checker)) {
-        // parseNodeToStaticValue can parse templates. Pass it through there to get a single static string
-        const styleObjNode = createStyleObjectNode_1.createStyleObjectNode(parseNodeToStaticValue_1.parseNodeToStaticValue(node.template, context), '{hash}');
-        const identifierName = getVarName_1.getVarName(node);
-        const name = createStyleObjectNode_1.getStaticCssClassName(styleObjNode);
-        keyframes[identifierName] = `animation-${name}`;
-        return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier('keyframes'), undefined, [
-            styleObjNode,
-        ]);
-    }
-    // keyframes({})
-    if (typescript_1.default.isCallExpression(node) &&
-        typescript_1.default.isIdentifier(node.expression) &&
-        node.expression.text === 'keyframes' &&
-        isImportedFromStyling_1.isImportedFromStyling(node.expression, checker)) {
-        if (typescript_1.default.isObjectLiteralExpression(node.arguments[0])) {
-            const styleObj = parseObjectToStaticValue_1.parseObjectToStaticValue(node.arguments[0], context);
-            const styleObjNode = createStyleObjectNode_1.createStyleObjectNode(styleObj, '{hash}');
-            const identifierName = getVarName_1.getVarName(node);
-            const name = createStyleObjectNode_1.getStaticCssClassName(styleObjNode);
-            keyframes[identifierName] = `animation-${name}`;
-            return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier('keyframes'), undefined, [
-                styleObjNode,
-            ]);
-        }
-    }
-    return;
-};
-exports.handleKeyframes = handleKeyframes;

package/dist/commonjs/lib/utils/handlePx2Rem.d.ts

@@ -1,6 +0,0 @@
-import { NodeTransformer } from './types';
-/**
- * Handle the CallExpression `px2rem` to do static conversion and remove the CallExpression.
- */
-export declare const handlePx2Rem: NodeTransformer;
-//# sourceMappingURL=handlePx2Rem.d.ts.map

package/dist/commonjs/lib/utils/handlePx2Rem.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handlePx2Rem.d.ts","sourceRoot":"","sources":["../../../../lib/utils/handlePx2Rem.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,eAAe,EAAC,MAAM,SAAS,CAAC;AAExC;;GAEG;AACH,eAAO,MAAM,YAAY,EAAE,eAkB1B,CAAC"}

package/dist/commonjs/lib/utils/handlePx2Rem.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handlePx2Rem = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const isImportedFromStyling_1 = require("./isImportedFromStyling");
-/**
- * Handle the CallExpression `px2rem` to do static conversion and remove the CallExpression.
- */
-const handlePx2Rem = (node, context) => {
-    if (typescript_1.default.isCallExpression(node) &&
-        typescript_1.default.isIdentifier(node.expression) &&
-        node.expression.text === 'px2rem' &&
-        isImportedFromStyling_1.isImportedFromStyling(node.expression, context.checker)) {
-        const [pxArgument, baseArgument] = node.arguments;
-        const base = baseArgument && typescript_1.default.isNumericLiteral(baseArgument) ? parseFloat(baseArgument.text) : 16;
-        if (typescript_1.default.isNumericLiteral(pxArgument)) {
-            const px = parseFloat(pxArgument.text);
-            return typescript_1.default.factory.createStringLiteral(`${px / base}rem`);
-        }
-    }
-    return;
-};
-exports.handlePx2Rem = handlePx2Rem;

package/dist/commonjs/lib/utils/isImportedFromStyling.d.ts

@@ -1,7 +0,0 @@
-import ts from 'typescript';
-/**
- * Checks if the node was imported from '@workday/canvas-kit-styling'. This is useful if you want to
- * limit transformation to only styling imports.
- */
-export declare function isImportedFromStyling(node: ts.Node, checker: ts.TypeChecker): boolean;
-//# sourceMappingURL=isImportedFromStyling.d.ts.map

package/dist/commonjs/lib/utils/isImportedFromStyling.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"isImportedFromStyling.d.ts","sourceRoot":"","sources":["../../../../lib/utils/isImportedFromStyling.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,WAAW,WAc3E"}

package/dist/commonjs/lib/utils/isImportedFromStyling.js

@@ -1,23 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isImportedFromStyling = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-/**
- * Checks if the node was imported from '@workday/canvas-kit-styling'. This is useful if you want to
- * limit transformation to only styling imports.
- */
-function isImportedFromStyling(node, checker) {
-    const symbol = checker.getSymbolAtLocation(node);
-    const declaration = (symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration) || (symbol === null || symbol === void 0 ? void 0 : symbol.declarations[0]);
-    if (declaration &&
-        typescript_1.default.isImportSpecifier(declaration) &&
-        typescript_1.default.isStringLiteral(declaration.parent.parent.parent.moduleSpecifier) &&
-        declaration.parent.parent.parent.moduleSpecifier.text === '@workday/canvas-kit-styling') {
-        return true;
-    }
-    return false;
-}
-exports.isImportedFromStyling = isImportedFromStyling;