@workday/canvas-kit-styling-transform 10.3.1 → 10.3.3

package/dist/es6/lib/utils/getFallbackVariable.d.ts

@@ -1,9 +0,0 @@
-/**
- * Looks for a variable value that doesn't include a fallback and automatically adds one if found in
- * the current cache of variables. This allows fallbacks to be automatically included in
- * environments without the variables defined. This is most useful for Storybook or other sandboxes
- * that may not have CSS Variables defined. The fallbacks will allow the UI to look correct without
- * additional setup. Fallbacks come from the `fallbackFiles` transform configuration.
- */
-export declare function getFallbackVariable(variableName: string, variables: Record<string, string>): string | undefined;
-//# sourceMappingURL=getFallbackVariable.d.ts.map

package/dist/es6/lib/utils/getFallbackVariable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getFallbackVariable.d.ts","sourceRoot":"","sources":["../../../../lib/utils/getFallbackVariable.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,MAAM,GAAG,SAAS,CAuBpB"}

package/dist/es6/lib/utils/getFallbackVariable.js

@@ -1,26 +0,0 @@
-/**
- * Looks for a variable value that doesn't include a fallback and automatically adds one if found in
- * the current cache of variables. This allows fallbacks to be automatically included in
- * environments without the variables defined. This is most useful for Storybook or other sandboxes
- * that may not have CSS Variables defined. The fallbacks will allow the UI to look correct without
- * additional setup. Fallbacks come from the `fallbackFiles` transform configuration.
- */
-export function getFallbackVariable(variableName, variables) {
-    const variable = variableName.includes('var(') ? variableName : variables[variableName];
-    if (variable && variable.includes('var(')) {
-        return variable.replace(/(var\(([A-Za-z0-9\-_]+)\))/, (
-        /** matched substring "var(--var-name)" */ _, 
-        /** the full match of the first group "var(--var-name)" */ varMatch, 
-        /** the variable name  - match of the second group "--var-name" */ cssVarName) => {
-            const value = variables[cssVarName];
-            if (value && value.startsWith('var')) {
-                return getFallbackVariable(value, variables);
-            }
-            return value || varMatch;
-        });
-    }
-    if (variable) {
-        return variable;
-    }
-    return;
-}

package/dist/es6/lib/utils/getVarName.d.ts

@@ -1,17 +0,0 @@
-import ts from 'typescript';
-/**
- * This function returns a calculated name of a node by walking up the AST and looking for nodes
- * with a `name` property that has an `Identifier` node type. The result is dash-case. This is
- * useful for automatically generating variable names based on a TS file.
- *
- * In the following example, the `baz` node would have a name of `foo-bar-baz`.
- * ```ts
- * const foo = {
- *   bar: {
- *     baz: ''
- *   }
- * }
- * ```
- */
-export declare function getVarName(node: ts.Node, parts?: string[]): string;
-//# sourceMappingURL=getVarName.d.ts.map

package/dist/es6/lib/utils/getVarName.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getVarName.d.ts","sourceRoot":"","sources":["../../../../lib/utils/getVarName.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,KAAK,GAAE,MAAM,EAAO,GAAG,MAAM,CAYtE"}

package/dist/es6/lib/utils/getVarName.js

@@ -1,26 +0,0 @@
-import ts from 'typescript';
-/**
- * This function returns a calculated name of a node by walking up the AST and looking for nodes
- * with a `name` property that has an `Identifier` node type. The result is dash-case. This is
- * useful for automatically generating variable names based on a TS file.
- *
- * In the following example, the `baz` node would have a name of `foo-bar-baz`.
- * ```ts
- * const foo = {
- *   bar: {
- *     baz: ''
- *   }
- * }
- * ```
- */
-export function getVarName(node, parts = []) {
-    // base case. Join all the parts
-    if (!node.parent || node.kind === ts.SyntaxKind.VariableStatement) {
-        return parts.join('-');
-    }
-    // Any node with a `name` property that is an identifier can add to the var name
-    if (node.name && ts.isIdentifier(node.name)) {
-        return getVarName(node.parent, [node.name.text, ...parts]);
-    }
-    return getVarName(node.parent, parts);
-}

package/dist/es6/lib/utils/handleCalc.d.ts

@@ -1,19 +0,0 @@
-import { NodeTransformer } from './types';
-/**
- * Handle all instances of `calc.*()` statically. It converts `calc.*` call expressions to template
- * string literals. The transformer will then transform the template literal into static values.
- *
- * ```ts
- * // in
- * calc.add('80%', '2px')
- *
- * // out
- * `calc(${'80%'} + ${'2px'})`
- * ```
- *
- * A template literal is used because the values might be Identifiers, PropertyAccessExpressions,
- * etc. The transform can handle template string literals with different spans, so we'll convert to
- * those as an intermediate step.
- */
-export declare const handleCalc: NodeTransformer;
-//# sourceMappingURL=handleCalc.d.ts.map

package/dist/es6/lib/utils/handleCalc.d.ts.map

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

package/dist/es6/lib/utils/handleCalc.js

@@ -1,55 +0,0 @@
-import ts from 'typescript';
-import { isImportedFromStyling } from './isImportedFromStyling';
-/**
- * Handle all instances of `calc.*()` statically. It converts `calc.*` call expressions to template
- * string literals. The transformer will then transform the template literal into static values.
- *
- * ```ts
- * // in
- * calc.add('80%', '2px')
- *
- * // out
- * `calc(${'80%'} + ${'2px'})`
- * ```
- *
- * A template literal is used because the values might be Identifiers, PropertyAccessExpressions,
- * etc. The transform can handle template string literals with different spans, so we'll convert to
- * those as an intermediate step.
- */
-export const handleCalc = (node, context) => {
-    if (ts.isCallExpression(node) &&
-        ts.isPropertyAccessExpression(node.expression) &&
-        ts.isIdentifier(node.expression.expression) &&
-        node.expression.expression.text === 'calc' &&
-        ts.isIdentifier(node.expression.name) &&
-        isImportedFromStyling(node.expression.expression, context.checker)) {
-        if (node.expression.name.text === 'add') {
-            return replaceWithTemplateString(node.arguments[0], node.arguments[1], ' + ');
-        }
-        if (node.expression.name.text === 'subtract') {
-            return replaceWithTemplateString(node.arguments[0], node.arguments[1], ' - ');
-        }
-        if (node.expression.name.text === 'multiply') {
-            return replaceWithTemplateString(node.arguments[0], node.arguments[1], ' * ');
-        }
-        if (node.expression.name.text === 'divide') {
-            return replaceWithTemplateString(node.arguments[0], node.arguments[1], ' / ');
-        }
-        if (node.expression.name.text === 'negate') {
-            return replaceWithTemplateString(node.arguments[0], ts.factory.createStringLiteral('-1'), ' * ');
-        }
-    }
-    return;
-};
-/**
- * Creates a template literal of the calculation result.
- */
-function replaceWithTemplateString(value1, value2, binder) {
-    if (ts.isStringLiteral(value1) && ts.isStringLiteral(value2)) {
-        return ts.factory.createStringLiteral(`calc(${value1.text}${binder}${value2.text})`);
-    }
-    return ts.factory.createTemplateExpression(ts.factory.createTemplateHead('calc('), [
-        ts.factory.createTemplateSpan(value1, ts.factory.createTemplateMiddle(binder)),
-        ts.factory.createTemplateSpan(value2, ts.factory.createTemplateTail(')')),
-    ]);
-}

package/dist/es6/lib/utils/handleCreateStencil.d.ts

@@ -1,6 +0,0 @@
-import { NodeTransformer } from './types';
-/**
- * Handle all arguments of the CallExpression `createStencil()`
- */
-export declare const handleCreateStencil: NodeTransformer;
-//# sourceMappingURL=handleCreateStencil.d.ts.map

package/dist/es6/lib/utils/handleCreateStencil.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleCreateStencil.d.ts","sourceRoot":"","sources":["../../../../lib/utils/handleCreateStencil.ts"],"names":[],"mappings":"AASA,OAAO,EAAC,eAAe,EAAqB,MAAM,SAAS,CAAC;AAG5D;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,eAqLjC,CAAC"}

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

@@ -1,196 +0,0 @@
-import ts from 'typescript';
-import { slugify } from '@workday/canvas-kit-styling';
-import { getVarName } from './getVarName';
-import { makeEmotionSafe } from './makeEmotionSafe';
-import { parseObjectToStaticValue } from './parseObjectToStaticValue';
-import { createStyleObjectNode } from './createStyleObjectNode';
-import { parseNodeToStaticValue } from './parseNodeToStaticValue';
-import { isImportedFromStyling } from './isImportedFromStyling';
-/**
- * Handle all arguments of the CallExpression `createStencil()`
- */
-export 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 (ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === 'createStencil' &&
-        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 = slugify(getVarName(node)).replace('-stencil', '');
-        if (ts.isObjectLiteralExpression(config)) {
-            // get variables first
-            const varsConfig = config.properties.find(property => {
-                return (property.name &&
-                    ts.isIdentifier(property.name) &&
-                    property.name.text === 'vars' &&
-                    ts.isPropertyAssignment(property));
-            });
-            function extractVariables(node) {
-                if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
-                    if (ts.isObjectLiteralExpression(node.initializer)) {
-                        return node.initializer.properties.map(extractVariables);
-                    }
-                    const varName = `${stencilName}-${makeEmotionSafe(node.name.text)}`;
-                    const varValue = `--${prefix}-${varName}`;
-                    variables[`${varName}`] = varValue;
-                    variables[makeEmotionSafe(node.name.text)] = varValue;
-                    tempVariables[makeEmotionSafe(node.name.text)] = varValue;
-                    // Evaluate the variable defaults
-                    stencilVariables[varValue] = parseNodeToStaticValue(node.initializer, context);
-                }
-            }
-            if (varsConfig && ts.isObjectLiteralExpression(varsConfig.initializer)) {
-                varsConfig.initializer.properties.forEach(variable => {
-                    extractVariables(variable);
-                });
-            }
-            config.properties.forEach((property, index, properties) => {
-                if (property.name && ts.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({
-                                ...stencilVariables,
-                                ...styleObj,
-                            });
-                            // We cast as any because TypeScript says these are readonly, but we're in a transform
-                            initializer.parent = property;
-                            properties[index] = ts.factory.createPropertyAssignment(property.name, initializer);
-                        }
-                    }
-                    // modifiers config object
-                    if (property.name.text === 'modifiers' &&
-                        ts.isPropertyAssignment(property) &&
-                        ts.isObjectLiteralExpression(property.initializer)) {
-                        property.initializer.properties.forEach(modifierProperty => {
-                            if (modifierProperty.name &&
-                                ts.isIdentifier(modifierProperty.name) &&
-                                ts.isPropertyAssignment(modifierProperty) &&
-                                ts.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(styleObj);
-                                        // // We cast as any because TypeScript says these are readonly, but we're in a transform
-                                        initializer.parent = modifier;
-                                        modifiers[index] = ts.factory.createPropertyAssignment(modifier.name, initializer);
-                                    }
-                                });
-                            }
-                        });
-                    }
-                    // compound config array
-                    if (property.name.text === 'compound' &&
-                        ts.isPropertyAssignment(property) &&
-                        ts.isArrayLiteralExpression(property.initializer)) {
-                        property.initializer.elements.forEach(element => {
-                            if (ts.isObjectLiteralExpression(element)) {
-                                element.properties.forEach((compoundProperty, index, compoundProperties) => {
-                                    // styles key
-                                    if (compoundProperty.name &&
-                                        ts.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(styleObj);
-                                            // We cast as any because TypeScript says these are readonly, but we're in a transform
-                                            initializer.parent = compoundProperty;
-                                            compoundProperties[index] = ts.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] = ts.factory.createStringLiteral(stencilName);
-        node.arguments[1].parent = node;
-        return node;
-    }
-    return;
-};
-/**
- * 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 (ts.isPropertyAssignment(property)) {
-        if (ts.isObjectLiteralExpression(property.initializer)) {
-            styleObj = parseObjectToStaticValue(property.initializer, context);
-        }
-        if (isFunctionLikeDeclaration(property.initializer)) {
-            const returnNode = getReturnStatement(property.initializer);
-            if (returnNode) {
-                styleObj = parseObjectToStaticValue(returnNode, context);
-            }
-        }
-    }
-    if (isFunctionLikeDeclaration(property)) {
-        const returnNode = getReturnStatement(property);
-        if (returnNode) {
-            styleObj = parseObjectToStaticValue(returnNode, context);
-        }
-    }
-    return styleObj;
-}
-function getReturnStatement(node) {
-    if (node.body && ts.isParenthesizedExpression(node.body)) {
-        return node.body.expression;
-    }
-    if (node.body && ts.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 (ts.isReturnStatement(statement)) {
-                returnNode = statement.expression;
-            }
-        });
-        return returnNode;
-    }
-    return undefined;
-}
-function isFunctionLikeDeclaration(node) {
-    return node.hasOwnProperty('body');
-}

package/dist/es6/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/es6/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/es6/lib/utils/handleCreateStyles.js

@@ -1,103 +0,0 @@
-import ts from 'typescript';
-import { parseObjectToStaticValue, parseStyleObjFromType } from './parseObjectToStaticValue';
-import { createStyleObjectNode } from './createStyleObjectNode';
-import { isImportedFromStyling } from './isImportedFromStyling';
-export 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 (ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === 'createStyles' &&
-        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 (ts.isObjectLiteralExpression(arg)) {
-                const styleObj = parseObjectToStaticValue(arg, context);
-                return 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 (ts.isIdentifier(arg)) {
-                const type = checker.getTypeAtLocation(arg);
-                // `createStyles` accepts strings as class names. If the class name is
-                if (type.isStringLiteral() || type.getFlags() & ts.TypeFlags.String) {
-                    return arg;
-                }
-                // The type must be a object
-                const styleObj = parseStyleObjFromType(type, context);
-                return 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;
-};

package/dist/es6/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/es6/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/es6/lib/utils/handleCreateVars.js

@@ -1,27 +0,0 @@
-import ts from 'typescript';
-import { slugify } from '@workday/canvas-kit-styling';
-import { getVarName } from './getVarName';
-import { makeEmotionSafe } from './makeEmotionSafe';
-export const handleCreateVars = (node, { prefix, variables }) => {
-    /**
-     * This will create a variable
-     */
-    if (ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === 'createVars') {
-        const id = slugify(getVarName(node)).replace('-vars', '');
-        const vars = node.arguments
-            .map(arg => ts.isStringLiteral(arg) && arg.text)
-            .filter(Boolean);
-        vars.forEach(v => {
-            variables[`${id}-${makeEmotionSafe(v)}`] = `--${prefix}-${id}-${makeEmotionSafe(v)}`;
-        });
-        return ts.factory.createCallExpression(node.expression, [], [
-            ts.factory.createObjectLiteralExpression([
-                ts.factory.createPropertyAssignment(ts.factory.createIdentifier('id'), ts.factory.createStringLiteral(`${prefix}-${id}`)),
-                ts.factory.createPropertyAssignment(ts.factory.createIdentifier('args'), ts.factory.createArrayLiteralExpression(vars.map(val => ts.factory.createStringLiteral(val)), false)),
-            ], false),
-        ]);
-    }
-    return;
-};

package/dist/es6/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/es6/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/es6/lib/utils/handleCssVar.js

@@ -1,26 +0,0 @@
-import ts from '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.
- */
-export const handleCssVar = node => {
-    // cssVar(a)
-    // cssVar(a, b)
-    if (ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === 'cssVar') {
-        if (node.arguments.length === 1) {
-            return node.arguments[0];
-        }
-        return ts.factory.createTemplateExpression(ts.factory.createTemplateHead('var('), [
-            ts.factory.createTemplateSpan(node.arguments[0], ts.factory.createTemplateMiddle(', ')),
-            ts.factory.createTemplateSpan(node.arguments[1], ts.factory.createTemplateTail(')')),
-        ]);
-    }
-    return;
-};

package/dist/es6/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/es6/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"}