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

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

@@ -1,76 +0,0 @@
-import ts from 'typescript';
-import { base, brand } from '@workday/canvas-tokens-web';
-import { parseNodeToStaticValue } from './parseNodeToStaticValue';
-export const handleFocusRing = (node, context) => {
-    // { ...focusRing() }
-    /**
-     * A spread assignment looks like:
-     *
-     * ```ts
-     * {
-     *   ...styles
-     * }
-     * ```
-     *
-     * https://ts-ast-viewer.com/#code/MYewdgzgLgBFCmBbADjAvDA3gMxCAXDAOQBGAhgE5EC+AUKJLAigEzpYB0Xzy1QA
-     */
-    if (ts.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 (ts.isCallExpression(node.expression) &&
-            ts.isIdentifier(node.expression.expression) &&
-            node.expression.expression.text === 'focusRing') {
-            const argumentObject = node.expression.arguments[0];
-            // defaults
-            const defaults = {
-                width: ts.factory.createStringLiteral('2px'),
-                separation: ts.factory.createStringLiteral('0px'),
-                inset: ts.factory.createIdentifier('undefined'),
-                innerColor: ts.factory.createStringLiteral(base.frenchVanilla100),
-                outerColor: ts.factory.createStringLiteral(brand.common.focusOutline),
-            };
-            if (argumentObject && ts.isObjectLiteralExpression(argumentObject)) {
-                argumentObject.properties.forEach(property => {
-                    if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name)) {
-                        defaults[property.name.text] = property.initializer;
-                    }
-                });
-            }
-            const inset = 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 ts.factory.createSpreadAssignment(ts.factory.createObjectLiteralExpression([
-                ts.factory.createPropertyAssignment(ts.factory.createIdentifier('boxShadow'), boxShadow),
-            ], false));
-        }
-    }
-    return;
-};
-function createTemplateExpression(head, ...args) {
-    const headNode = ts.factory.createTemplateHead(head);
-    const spanNodes = args.reduce((result, value, index) => {
-        if (typeof value !== 'string') {
-            const literal = index === args.length - 1
-                ? ts.factory.createTemplateTail('')
-                : index === args.length - 2
-                    ? ts.factory.createTemplateTail(args[index + 1])
-                    : ts.factory.createTemplateMiddle(args[index + 1]);
-            result.push(ts.factory.createTemplateSpan(value, literal));
-        }
-        return result;
-    }, []);
-    return ts.factory.createTemplateExpression(headNode, spanNodes);
-}

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

@@ -1,40 +0,0 @@
-import ts from 'typescript';
-import { parseNodeToStaticValue } from './parseNodeToStaticValue';
-import { getVarName } from './getVarName';
-import { createStyleObjectNode, getStaticCssClassName } from './createStyleObjectNode';
-import { isImportedFromStyling } from './isImportedFromStyling';
-import { parseObjectToStaticValue } from './parseObjectToStaticValue';
-export const handleKeyframes = (node, context) => {
-    const { checker, keyframes } = context;
-    // keyframes`css`
-    if (ts.isTaggedTemplateExpression(node) &&
-        ts.isIdentifier(node.tag) &&
-        node.tag.text === 'keyframes' &&
-        isImportedFromStyling(node.tag, checker)) {
-        // parseNodeToStaticValue can parse templates. Pass it through there to get a single static string
-        const styleObjNode = createStyleObjectNode(parseNodeToStaticValue(node.template, context), '{hash}');
-        const identifierName = getVarName(node);
-        const name = getStaticCssClassName(styleObjNode);
-        keyframes[identifierName] = `animation-${name}`;
-        return ts.factory.createCallExpression(ts.factory.createIdentifier('keyframes'), undefined, [
-            styleObjNode,
-        ]);
-    }
-    // keyframes({})
-    if (ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === 'keyframes' &&
-        isImportedFromStyling(node.expression, checker)) {
-        if (ts.isObjectLiteralExpression(node.arguments[0])) {
-            const styleObj = parseObjectToStaticValue(node.arguments[0], context);
-            const styleObjNode = createStyleObjectNode(styleObj, '{hash}');
-            const identifierName = getVarName(node);
-            const name = getStaticCssClassName(styleObjNode);
-            keyframes[identifierName] = `animation-${name}`;
-            return ts.factory.createCallExpression(ts.factory.createIdentifier('keyframes'), undefined, [
-                styleObjNode,
-            ]);
-        }
-    }
-    return;
-};

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

@@ -1,19 +0,0 @@
-import ts from 'typescript';
-import { isImportedFromStyling } from './isImportedFromStyling';
-/**
- * Handle the CallExpression `px2rem` to do static conversion and remove the CallExpression.
- */
-export const handlePx2Rem = (node, context) => {
-    if (ts.isCallExpression(node) &&
-        ts.isIdentifier(node.expression) &&
-        node.expression.text === 'px2rem' &&
-        isImportedFromStyling(node.expression, context.checker)) {
-        const [pxArgument, baseArgument] = node.arguments;
-        const base = baseArgument && ts.isNumericLiteral(baseArgument) ? parseFloat(baseArgument.text) : 16;
-        if (ts.isNumericLiteral(pxArgument)) {
-            const px = parseFloat(pxArgument.text);
-            return ts.factory.createStringLiteral(`${px / base}rem`);
-        }
-    }
-    return;
-};

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

@@ -1,16 +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 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 &&
-        ts.isImportSpecifier(declaration) &&
-        ts.isStringLiteral(declaration.parent.parent.parent.moduleSpecifier) &&
-        declaration.parent.parent.parent.moduleSpecifier.text === '@workday/canvas-kit-styling') {
-        return true;
-    }
-    return false;
-}

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

@@ -1,7 +0,0 @@
-/**
- * Util function to fix an issue with Emotion by
- * appending `EmotionIssue#3066` to end of css variable
- * See issue: [#3066](https://github.com/emotion-js/emotion/issues/3066)
- */
-export declare function makeEmotionSafe(key: string): string;
-//# sourceMappingURL=makeEmotionSafe.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"makeEmotionSafe.d.ts","sourceRoot":"","sources":["../../../../lib/utils/makeEmotionSafe.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKnD"}

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

@@ -1,11 +0,0 @@
-/**
- * Util function to fix an issue with Emotion by
- * appending `EmotionIssue#3066` to end of css variable
- * See issue: [#3066](https://github.com/emotion-js/emotion/issues/3066)
- */
-export function makeEmotionSafe(key) {
-    if (key.endsWith('label')) {
-        return `${key}-emotion-safe`;
-    }
-    return key;
-}

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

@@ -1,7 +0,0 @@
-import ts from 'typescript';
-import { TransformerContext } from './types';
-/**
- * This is the workhorse of statically analyzing style values
- */
-export declare function parseNodeToStaticValue(node: ts.Node, context: TransformerContext): string;
-//# sourceMappingURL=parseNodeToStaticValue.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"parseNodeToStaticValue.d.ts","sourceRoot":"","sources":["../../../../lib/utils/parseNodeToStaticValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAM5B,OAAO,EAAC,kBAAkB,EAAC,MAAM,SAAS,CAAC;AAE3C;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAuGzF"}

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

@@ -1,142 +0,0 @@
-import ts from 'typescript';
-import { slugify } from '@workday/canvas-kit-styling';
-import { makeEmotionSafe } from './makeEmotionSafe';
-import { getErrorMessage } from './getErrorMessage';
-/**
- * This is the workhorse of statically analyzing style values
- */
-export function parseNodeToStaticValue(node, context) {
-    const { checker, variables, keyframes } = context;
-    /**
-     * String literals like 'red' or empty Template Expressions like `red`
-     */
-    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
-        return node.text;
-    }
-    // 12
-    if (ts.isNumericLiteral(node)) {
-        return `${node.text}px`;
-    }
-    // undefined
-    if (ts.isIdentifier(node) && node.text === 'undefined') {
-        return 'undefined';
-    }
-    // a.b
-    if (ts.isPropertyAccessExpression(node)) {
-        const varName = getCSSVariableKey(getPropertyAccessExpressionText(node));
-        if (variables[varName]) {
-            return variables[varName];
-        }
-        if (keyframes[varName]) {
-            return keyframes[varName];
-        }
-    }
-    // [a.b]
-    if (ts.isComputedPropertyName(node) && ts.isPropertyAccessExpression(node.expression)) {
-        const varName = getCSSVariableKey(getPropertyAccessExpressionText(node.expression));
-        if (variables[varName]) {
-            return variables[varName];
-        }
-        if (keyframes[varName]) {
-            return keyframes[varName];
-        }
-    }
-    /**
-     * ```ts
-     * `border 1px ${myVars.colors.border}`
-     * ```
-     */
-    if (ts.isTemplateExpression(node)) {
-        return getStyleValueFromTemplateExpression(node, context);
-    }
-    /**
-     * An Identifier is a simple variable. It may represent a variable, so we'll check it before
-     * moving on. This typically happens in stencils.
-     */
-    if (ts.isIdentifier(node)) {
-        if (variables[node.text]) {
-            return variables[node.text];
-        }
-        if (keyframes[node.text]) {
-            return keyframes[node.text];
-        }
-    }
-    if (ts.isElementAccessExpression(node)) {
-        const value = parseTypeToStaticValue(checker.getTypeAtLocation(node));
-        if (value) {
-            return value;
-        }
-    }
-    // If we got here, we cannot statically analyze by the AST alone. We have to check the type of the
-    // correct AST Node
-    if (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node)) {
-        const value = parseTypeToStaticValue(checker.getTypeAtLocation(node));
-        if (value) {
-            return value;
-        }
-    }
-    if (ts.isComputedPropertyName(node)) {
-        const value = parseTypeToStaticValue(checker.getTypeAtLocation(node.expression));
-        if (value) {
-            return value;
-        }
-    }
-    // we don't know what this is, we need to throw an error
-    const type = checker.getTypeAtLocation(node);
-    const typeValue = checker.typeToString(type);
-    throw new Error(`Unknown type at: "${node.getText()}". Received "${typeValue}"\n${getErrorMessage(node)}\nFor static analysis of styles, please make sure all types resolve to string or numeric literals. Please use 'const' instead of 'let'. If using an object, cast using "as const" or use an interface with string or numeric literals.`);
-}
-function parseTypeToStaticValue(type) {
-    if (type.isStringLiteral()) {
-        return type.value;
-    }
-    if (type.isNumberLiteral()) {
-        return `${type.value}px`;
-    }
-}
-function getCSSVariableKey(text) {
-    const [id, name] = getVariableNameParts(text);
-    return `${slugify(id)}-${makeEmotionSafe(name)}`;
-}
-/**
- * A `PropertyExpression` is an expression with a dot in it. Like `a.b.c`. It may be nested. This
- * function will walk the AST and create a string like `a.b.c` to be passed on to variable name
- * generation. This will be used for CSS variable lookups.
- */
-function getPropertyAccessExpressionText(node) {
-    if (ts.isIdentifier(node.name)) {
-        if (ts.isIdentifier(node.expression)) {
-            return `${node.expression.text}.${node.name.text}`;
-        }
-        if (ts.isPropertyAccessExpression(node.expression)) {
-            return `${getPropertyAccessExpressionText(node.expression)}.${node.name.text}`;
-        }
-    }
-    return '';
-}
-function getVariableNameParts(input) {
-    const parts = input.split('.');
-    // grab the last item in the array. This will also mutate the array, removing the last item
-    const variable = parts.pop();
-    return [parts.join('.').replace(/(vars|stencil|styles)/i, ''), variable];
-}
-/**
- * Gets a static string value from a template expression. It could recurse.
- */
-function getStyleValueFromTemplateExpression(node, context) {
-    if (!node) {
-        return '';
-    }
-    if (ts.isTemplateExpression(node)) {
-        return (getStyleValueFromTemplateExpression(node.head, context) +
-            node.templateSpans.map(value => getStyleValueFromTemplateExpression(value, context)).join(''));
-    }
-    if (ts.isTemplateHead(node) || ts.isTemplateTail(node) || ts.isTemplateMiddle(node)) {
-        return node.text;
-    }
-    if (ts.isTemplateSpan(node)) {
-        return (parseNodeToStaticValue(node.expression, context) +
-            getStyleValueFromTemplateExpression(node.literal, context));
-    }
-    return '';
-}

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

@@ -1,13 +0,0 @@
-import ts from 'typescript';
-import { TransformerContext } from './types';
-export declare type NestedStyleObject = {
-    [key: string]: string | NestedStyleObject;
-};
-export declare function parseObjectToStaticValue(node: ts.Node, context: TransformerContext): NestedStyleObject;
-/**
- * If we're here, we have a `ts.Type` that represents a style object. We try to parse a style object
- * from the AST, but we might have something that is more complicated like a function call or an
- * identifier that represents an object. It could be imported from another file.
- */
-export declare function parseStyleObjFromType(type: ts.Type, context: TransformerContext): Record<string, any>;
-//# sourceMappingURL=parseObjectToStaticValue.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"parseObjectToStaticValue.d.ts","sourceRoot":"","sources":["../../../../lib/utils/parseObjectToStaticValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAI5B,OAAO,EAAC,kBAAkB,EAAC,MAAM,SAAS,CAAC;AAE3C,oBAAY,iBAAiB,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,iBAAiB,CAAA;CAAC,CAAC;AAE5E,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,OAAO,EAAE,kBAAkB,GAC1B,iBAAiB,CAUnB;AA+DD;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,kBAAkB,uBA0B/E"}

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

@@ -1,110 +0,0 @@
-import ts from 'typescript';
-import { getFallbackVariable } from './getFallbackVariable';
-import { parseNodeToStaticValue } from './parseNodeToStaticValue';
-export function parseObjectToStaticValue(node, context) {
-    let styleObj = {};
-    if (ts.isObjectLiteralExpression(node)) {
-        node.properties.forEach(property => {
-            styleObj = { ...styleObj, ...parsePropertyToStaticValue(property, context) };
-        });
-    }
-    return styleObj;
-}
-function parsePropertyToStaticValue(node, context) {
-    const styleObj = {};
-    // { name: value }
-    if (ts.isPropertyAssignment(node)) {
-        const key = ts.isIdentifier(node.name)
-            ? node.name.text
-            : parseNodeToStaticValue(node.name, context);
-        if (key) {
-            if (ts.isObjectLiteralExpression(node.initializer)) {
-                // nested
-                styleObj[key] = parseObjectToStaticValue(node.initializer, context);
-            }
-            else {
-                styleObj[key] = maybeWrapCSSVariables(parseNodeToStaticValue(node.initializer, context), context.variables);
-                parseNodeToStaticValue(node.initializer, context);
-            }
-            return styleObj;
-        }
-    }
-    // { name: value } (types)
-    if (ts.isPropertySignature(node)) {
-        const key = ts.isIdentifier(node.name)
-            ? node.name.text
-            : parseNodeToStaticValue(node.name, context);
-        if (key) {
-            if (key.includes('&') || key.startsWith(':')) {
-                // nested
-                styleObj[key] = parseObjectToStaticValue(node.type, context);
-            }
-            else {
-                styleObj[key] =
-                    maybeWrapCSSVariables(parseNodeToStaticValue(node.type, context), context.variables) ||
-                        '';
-            }
-            return styleObj;
-        }
-    }
-    // {...{key: 'value'}}
-    if (ts.isSpreadAssignment(node) && ts.isObjectLiteralExpression(node.expression)) {
-        // recurse to parse a nested ObjectLiteralExpression
-        return parseObjectToStaticValue(node.expression, context);
-    }
-    // { ...value }
-    if (ts.isSpreadAssignment(node)) {
-        // Spread assignments are a bit complicated to use the AST to figure out, so we'll ask the
-        // TypeScript type checker.
-        const type = context.checker.getTypeAtLocation(node.expression);
-        context.checker.typeToString(type);
-        return parseStyleObjFromType(type, context);
-    }
-    return styleObj;
-}
-/**
- * If we're here, we have a `ts.Type` that represents a style object. We try to parse a style object
- * from the AST, but we might have something that is more complicated like a function call or an
- * identifier that represents an object. It could be imported from another file.
- */
-export function parseStyleObjFromType(type, context) {
-    const styleObj = {};
-    // Gets all the properties of the type object
-    return type.getProperties().reduce((result, property) => {
-        const declaration = property.valueDeclaration;
-        // we might have generics, so we'll use the type of the symbol instead of the type at the
-        // declaration. This resolves generics like `T` into literal values if they exist.
-        const propType = context.checker.getTypeOfSymbolAtLocation(property, declaration);
-        if (propType.isStringLiteral()) {
-            // This isn't a component variable, it is a static CSS variable
-            result[property.name] = propType.value;
-            return result;
-        }
-        if (propType.isNumberLiteral()) {
-            result[property.name] = `${propType.value}px`;
-            return result;
-        }
-        return {
-            ...result,
-            ...parsePropertyToStaticValue(declaration, context),
-        };
-    }, styleObj);
-}
-/**
- * Wrap all unwrapped CSS Variables. For example, `{padding: '--foo'}` will be replaced with
- * `{padding: 'var(--foo)'}`. It also works on variables in the middle of the property.
- */
-function maybeWrapCSSVariables(input, variables) {
-    // matches an string starting with `--` that isn't already wrapped in a `var()`. It tries to match
-    // any character that isn't a valid separator in CSS
-    return input.replace(/([a-z]*[ (]*)(--[^\s;,'})]+)/gi, (match, prefix, variable) => {
-        if (prefix.startsWith('var(')) {
-            return match;
-        }
-        const fallbackVariable = getFallbackVariable(variable, variables);
-        const fallback = fallbackVariable
-            ? `, ${maybeWrapCSSVariables(fallbackVariable, variables)}`
-            : '';
-        return `${prefix}var(${variable}${fallback})`;
-    });
-}

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

@@ -1,16 +0,0 @@
-import ts from 'typescript';
-export declare type TransformerContext = {
-    checker: ts.TypeChecker;
-    prefix: string;
-    variables: Record<string, string>;
-    keyframes: Record<string, string>;
-};
-/**
- * Transformer function type. A transformer will be called by the TypeScript AST transformer visitor
- * from the bottom of the tree to the top (inside-out/leaf first, root last). If a transformer knows
- * how to handle the AST node, a node should be returned. Even if no transformation is desired,
- * returning a node shortcuts processing. The visitor will call all NodeTransformers until a match
- * is met.
- */
-export declare type NodeTransformer = (node: ts.Node, context: TransformerContext) => ts.Node | void;
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../lib/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,oBAAY,kBAAkB,GAAG;IAC/B,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC,CAAC;AAEF;;;;;;GAMG;AACH,oBAAY,eAAe,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,kBAAkB,KAAK,EAAE,CAAC,IAAI,GAAG,IAAI,CAAC"}

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

@@ -1 +0,0 @@
-export {};