@workday/canvas-kit-styling-transform 13.2.1 → 13.2.2

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyStringify = void 0;
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-fallthrough */
+/* eslint-disable default-case */
+const stylis_1 = require("stylis");
+function strlen(input) {
+    return input.length;
+}
+const prettyStringify = (element, index, children, callback) => {
+    switch (element.type) {
+        case stylis_1.LAYER:
+            if (element.children.length) {
+                break;
+            }
+        case stylis_1.IMPORT:
+        case stylis_1.DECLARATION:
+            return (element.return =
+                element.return ||
+                    '  ' + element.value.replace(':', ': ') + (index === children.length - 1 ? '' : '\n'));
+        case stylis_1.COMMENT:
+            return `${element.value}\n`;
+        case stylis_1.KEYFRAMES:
+            return ((element.return =
+                element.value +
+                    ' {\n' +
+                    (0, stylis_1.serialize)(element.children, callback)
+                        .split('\n')
+                        .map(i => `  ${i}`)
+                        .join('\n') +
+                    '}').replace(/\s\s\}$/, '}') + '\n');
+        case stylis_1.RULESET:
+            if (!strlen((element.value = element.props.join(', ')))) {
+                return '';
+            }
+    }
+    const childStr = (0, stylis_1.serialize)(element.children, callback);
+    if (childStr) {
+        element.return = `${element.value} {\n${childStr}\n}\n\n`;
+        return element.return;
+    }
+    return '';
+};
+exports.prettyStringify = prettyStringify;

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

@@ -0,0 +1,210 @@
+import ts from 'typescript';
+export type TransformerContext = {
+    checker: ts.TypeChecker;
+    prefix: string;
+    getPrefix: (path: string) => string;
+    /**
+     * Name and value pairs for things that cannot be statically resolved via the type system. The
+     * name is resolved via `getPropertyAccessExpressionText` and the value can be anything. It should
+     * be whatever you want the runtime value to be, which is usually a hash. For example:
+     *
+     * ```ts
+     * const myVars = createVars('color');
+     *
+     * color: myVars.color
+     * ```
+     *
+     * The type of `myVars.color` is `string`, but both in runtime and transpile time, the
+     * `myVars.color` is resolved to a hard value. The `names` cache is a lookup to that value. The
+     * `names` cache does not track the AST of `color`, so `const {color} = myVars` will not work. The
+     * key comes from `getPropertyAccessExpressionText` which replaces `.` with `-`.
+     */
+    names: Record<string, string>;
+    /**
+     * Extracted names is a mapping from `names` to a value that will be output to CSS. If you add an
+     * entry to `names`, add an entry to `extractedNames` where the `key` of `extractedNames` is the
+     * `value` of `names`.
+     *
+     * For example:
+     * ```ts
+     * // names
+     * { "myVars.foo": "--css-12345" },
+     * // extractedNames
+     * { "--css-12345": "--css-my-vars-foo" }
+     * ```
+     *
+     * The value in `names` will be used for transformation of TypeScript files into JavaScript files.
+     * The `extractedNames` will be used for the output CSS files.
+     */
+    extractedNames: Record<string, string>;
+    /**
+     * Variable scoping allows for a variable lookup to match a predefined scope. For example, in
+     * stencils, the `base` config can take a function with the locally defined variable names.
+     *
+     * ```ts
+     * const myStencil = createStencil({
+     *   vars: {color: 'red'},
+     *   base({color}) {
+     *     return {
+     *       [color]: 'blue'
+     *     }
+     *   }
+     * })
+     * ```
+     *
+     * In this case, a name lookup would fail because there's no global name named `color`. There's a
+     * global name named `my-color` which is the fully-qualified name. The stencil parser will add
+     * `my-` as a name scoping when processing style attributes for name lookup purposes.
+     */
+    nameScope?: string;
+    /**
+     * All styles will be collected here. These styles will then be flushed out to CSS files according
+     * to the `getFileName` function.
+     */
+    styles: StylesOutput;
+    /**
+     * The cache is for idempotent style inserts. Styles are hashed based on file name and position in
+     * the file.
+     */
+    cache: Record<string, string>;
+    getFileName: (path: string) => string;
+    objectTransforms: ObjectTransform[];
+    propertyTransforms: PropertyTransform[];
+    fileName: string;
+    transform: NodeTransformer;
+    extractCSS: boolean;
+    seed: string;
+};
+export type NestedStyleObject = {
+    [key: string]: number | string | NestedStyleObject;
+};
+/**
+ * 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 type NodeTransformer = (node: ts.Node, context: TransformerContext) => ts.Node | void;
+/**
+ * Used to collect styles. The format will be:
+ *
+ * ```js
+ * {
+ *   '/absolute/file/name': [
+ *     '.styles-1 { ... }'
+ *   ]
+ * }
+ * ```
+ */
+export type StylesOutput = Record<string, string[]>;
+export interface Config {
+    /**
+     * The prefix for all CSS class names and variables. This should be something short and
+     * distinguish your CSS class names from others on the page.
+     */
+    prefix?: string;
+    /**
+     * If you wish to automatically include CSS variable fallbacks, you can provide paths to CSS files
+     * that contain CSS variables. Fallbacks are useful if you expect your CSS to be loaded in an
+     * environment that might not include these CSS files. An example might be Storybook or other dev
+     * environments where you want your CSS to look good even in these environments. Fallbacks make
+     * bigger files because fallbacks are embedded.
+     *
+     * For example:
+     * ```ts
+     * const myComponent = createStyles({
+     *   color: '--primary-color-100'
+     * })
+     * ```
+     *
+     * If you provide a fallback file that defines `--primary-color-100`, the fallback will be
+     * inlined:
+     * ```css
+     * // without
+     * .my-component{color:var(--primary-color-100);}
+     *
+     * // with fallback
+     * .my-component{color:var(--primary-color-100,#0000ff);}
+     * ```
+     *
+     * The benefit is your CSS will work even without the files that define all your global CSS
+     * variables.
+     */
+    fallbackFiles?: string[];
+    /**
+     * Optional additional transforms. A transform takes an AST node and optionally returns a new AST
+     * node. This is useful if your source files use custom utility functions. The style
+     * transformation process must receive static strings while reading your source files. The base
+     * transformers handle all style utilities provided by `@workday/canvas-kit-styling`, but you may
+     * use more. The transformer makes use of TypeScript's type checker to extract a static types out
+     * of variables, but will throw errors if it finds a generic type like `string` or `number`. If
+     * you get these errors and the error points to a function, maybe you need an additional
+     * transformer to understand the code. Some simple examples from `@workday/canvas-kit-styling` are
+     * `px2rem` and `calc.*`. Those have special handlers that are allowed to return new AST nodes
+     * that can be further processed. You can return `NumericLiteral`, `StringLiteral`, or
+     * `TemplateExpression` AST nodes. You can see `handlePx2Rem` and `handleCalc` transformers as
+     * examples as well as associated tests.
+     *
+     * Transforms are called using the visitor pattern. The order is innermost to outermost of the
+     * AST. This means if you have a special utility function used to return a style property, it will
+     * be called before the `createStyles` or `createStencils` is called.
+     *
+     * https://ts-ast-viewer.com/#code/MYewdgzgLgBAtgTwMIjgB3AUzLAvDYAJ0wEMpMBlKBAG0wgAoBvAKBhjRIBMuBLMAOYAuGAMxQACtz6CGAcgAeNOQEoWAXxVA
+     * ```ts
+     * const myComponent = createStyles({
+     *   padding: getPadding('xl')
+     * })
+     * ```
+     *
+     * In this example, your transform will be called with `'xl'`, `getPadding`, the `padding`
+     * PropertyAssignment, `createStyles`, then variable declarations for `myComponent`. You must
+     * create your own filters for each AST node so you only transform the correct nodes. You can
+     * visit ts-ast-viewer.com to see the AST and types. You can also use the factory creator to
+     * return new AST.
+     */
+    additionalTransforms?: NodeTransformer[];
+    /**
+     * Should the CSS be statically extracted into CSS files? If `true`, CSS files will be created
+     * according to the `getFileName` configuration. If `getFileName` is not defined, a CSS file will
+     * be created with the same name as the source file with a `.css` extension.
+     */
+    extractCSS?: boolean;
+    /**
+     * This will be called every time a style or keyframe needs to be injected into extracted style
+     * files. By default, the file name will be the current file with the `.tsx` replaced with a
+     * `.css`. If you wish to move or combine styles into a file, provide a custom `getFileName`. You
+     * can return the same file path for multiple sources. If the same file is used (maybe always
+     * returning `index.css`), new styles will be appended to the end of the file.
+     */
+    getFileName?: (path: string) => string;
+    /**
+     * Object transforms take an AST node that represents a style object and turn it into a
+     * `NestedStyleObject` or return `void`. If an object transform returns an object, transformation
+     * parsing stops on that node. If `void` is returned, processing continues using
+     * `parseObjectToStaticValue`. These transforms are useful if you have custom utility functions
+     * that are not statically parsable by the static styling transformer.
+     */
+    objectTransforms?: ObjectTransform[];
+    /**
+     * Property transforms take an AST node that represents a style property value and turn it into a
+     * static string. The transform is static and will generate a CSS style string for injection
+     * directly into the browser (or CSS file). A string is the only valid return type. Returning
+     * `void` instructs the transform to move on to other transforms. Returning a string will
+     * short-circuit other property transforms or the default property transform.
+     */
+    propertyTransforms?: PropertyTransform[];
+    /**
+     * Optional function for getting a prefix given a file path. This is useful if you want to have a
+     * different prefix for each module in a monorepo.
+     */
+    getPrefix?: (path: string) => string;
+    /**
+     * Optional seed for the hash. This can be useful if you want each build to have a different hash.
+     * If you provide the same seed, the same hash will be generated for every style.
+     */
+    seed?: string;
+}
+export type ObjectTransform = (node: ts.Node, context: TransformerContext) => NestedStyleObject | void;
+export type PropertyTransform = (node: ts.Node, context: TransformerContext) => string | void;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../lib/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACpC;;;;;;;;;;;;;;;OAeG;IACH,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B;;;;;;;;;;;;;;;OAeG;IACH,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC;;;;;;;;;;;;;;;;;;OAkBG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,MAAM,EAAE,YAAY,CAAC;IACrB;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IACtC,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,eAAe,CAAC;IAC3B,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,iBAAiB,CAAA;CAAC,CAAC;AAErF;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,kBAAkB,KAAK,EAAE,CAAC,IAAI,GAAG,IAAI,CAAC;AAE7F;;;;;;;;;;GAUG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;AAEpD,MAAM,WAAW,MAAM;IACrB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,oBAAoB,CAAC,EAAE,eAAe,EAAE,CAAC;IAEzC;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAEvC;;;;;;OAMG;IACH,gBAAgB,CAAC,EAAE,eAAe,EAAE,CAAC;IAErC;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAEzC;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAErC;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,eAAe,GAAG,CAC5B,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,OAAO,EAAE,kBAAkB,KACxB,iBAAiB,GAAG,IAAI,CAAC;AAE9B,MAAM,MAAM,iBAAiB,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,kBAAkB,KAAK,MAAM,GAAG,IAAI,CAAC"}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commonjs/lib/webpack-loader.d.ts

@@ -0,0 +1,7 @@
+interface LoaderContext {
+    getOptions: () => ReturnType<import('./webpackPlugin').StylingWebpackPlugin['getLoaderOptions']>;
+    resourcePath: string;
+}
+export default function typescriptLoaderWithTransformers(this: LoaderContext, source: string): string;
+export {};
+//# sourceMappingURL=webpack-loader.d.ts.map

package/dist/commonjs/lib/webpack-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpack-loader.d.ts","sourceRoot":"","sources":["../../../lib/webpack-loader.ts"],"names":[],"mappings":"AAEA,UAAU,aAAa;IACrB,UAAU,EAAE,MAAM,UAAU,CAAC,OAAO,iBAAiB,EAAE,oBAAoB,CAAC,kBAAkB,CAAC,CAAC,CAAC;IACjG,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,CAAC,OAAO,UAAU,gCAAgC,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,UAoB3F"}

package/dist/commonjs/lib/webpack-loader.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const typescript_1 = __importDefault(require("typescript"));
+function typescriptLoaderWithTransformers(source) {
+    const { builderProgram, transformers, postTransform } = this.getOptions();
+    const id = this.resourcePath;
+    const program = builderProgram.getProgram();
+    const sourceFile = program.getSourceFile(id);
+    if (!sourceFile) {
+        return source;
+    }
+    const printer = typescript_1.default.createPrinter(program.getCompilerOptions());
+    const transformed = printer.printFile(typescript_1.default
+        .transform(sourceFile, transformers, program.getCompilerOptions())
+        .transformed.find(s => s.fileName === id) || sourceFile);
+    return (postTransform === null || postTransform === void 0 ? void 0 : postTransform(transformed, id)) || transformed;
+}
+exports.default = typescriptLoaderWithTransformers;

package/dist/commonjs/lib/webpackPlugin.d.ts

@@ -0,0 +1,31 @@
+import ts from 'typescript';
+type Transformer = (program: ts.Program) => ts.TransformerFactory<ts.SourceFile>;
+interface PluginConfig {
+    tsconfigPath: string;
+    /**
+     * Optional list of transformers. The default is running the styleTransformer. If you wish to run
+     * additional transformers, you can pass them in here.
+     *
+     * @example
+     * ```ts
+     * new StylingWebpackPlugin({
+     *   tsconfigPath: './tsconfig.json',
+     *   transformers: [styleTransformer, myTransformer],
+     * })
+     * ```
+     */
+    transformers?: (undefined | Transformer)[];
+    postTransform?: (code: string, id: string) => string | undefined;
+}
+export declare class StylingWebpackPlugin {
+    private compilerOptions;
+    builderProgram: ts.BuilderProgram;
+    transformers: ts.TransformerFactory<ts.SourceFile>[];
+    postTransform?: (code: string, id: string) => string | undefined;
+    close: () => void;
+    constructor(config: PluginConfig);
+    getLoaderOptions(): this;
+    apply(compiler: import('webpack').Compiler): void;
+}
+export {};
+//# sourceMappingURL=webpackPlugin.d.ts.map

package/dist/commonjs/lib/webpackPlugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webpackPlugin.d.ts","sourceRoot":"","sources":["../../../lib/webpackPlugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAK5B,KAAK,WAAW,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,KAAK,EAAE,CAAC,kBAAkB,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC;AAIjF,UAAU,YAAY;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;;;;;;;OAWG;IACH,YAAY,CAAC,EAAE,CAAC,SAAS,GAAG,WAAW,CAAC,EAAE,CAAC;IAE3C,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;CAClE;AAED,qBAAa,oBAAoB;IAC/B,OAAO,CAAC,eAAe,CAAqB;IACrC,cAAc,EAAG,EAAE,CAAC,cAAc,CAAC;IACnC,YAAY,EAAG,EAAE,CAAC,kBAAkB,CAAC,EAAE,CAAC,UAAU,CAAC,EAAE,CAAC;IACtD,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACjE,KAAK,EAAE,MAAM,IAAI,CAAC;gBAEb,MAAM,EAAE,YAAY;IAoBhC,gBAAgB;IAIhB,KAAK,CAAC,QAAQ,EAAE,OAAO,SAAS,EAAE,QAAQ;CAS3C"}

package/dist/commonjs/lib/webpackPlugin.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylingWebpackPlugin = void 0;
+const createTypeScriptWatchProgram_1 = require("./createTypeScriptWatchProgram");
+const styleTransform_1 = __importDefault(require("./styleTransform"));
+const pluginName = 'StylingWebpackPlugin';
+class StylingWebpackPlugin {
+    constructor(config) {
+        var _a;
+        const tsconfigPath = (_a = config.tsconfigPath) !== null && _a !== void 0 ? _a : './tsconfig.json';
+        this.compilerOptions = (0, createTypeScriptWatchProgram_1.getCompilerOptions)(tsconfigPath);
+        const [_builderProgram, close] = (0, createTypeScriptWatchProgram_1.startWatch)(this.compilerOptions, tsconfigPath, (builderProgram) => {
+            var _a;
+            this.builderProgram = builderProgram;
+            this.transformers = ((_a = config.transformers) !== null && _a !== void 0 ? _a : [styleTransform_1.default])
+                .filter(t => t !== undefined)
+                .map(t => t(this.builderProgram.getProgram()));
+        });
+        this.close = close;
+        this.postTransform = config.postTransform;
+    }
+    getLoaderOptions() {
+        return this;
+    }
+    apply(compiler) {
+        // We must close down the watch program when the compiler shuts down. This doesn't happen
+        // automatically when using the watch program and the watch will shut down from a SIGINT. When a
+        // webpack production build is initiated, the shutdown signifies the build is complete and we
+        // need to end the watch program.
+        compiler.hooks.shutdown.tap(pluginName, () => {
+            this.close();
+        });
+    }
+}
+exports.StylingWebpackPlugin = StylingWebpackPlugin;

package/dist/commonjs/spec/createProgramFromSource.d.ts

@@ -0,0 +1,8 @@
+import * as ts from 'typescript';
+export declare function createProgramFromSource(source: string): ts.Program;
+export declare function createProgramFromSource(filename: string, source: string): ts.Program;
+export declare function createProgramFromSource(sources: {
+    filename: string;
+    source: string;
+}[]): ts.Program;
+//# sourceMappingURL=createProgramFromSource.d.ts.map

package/dist/commonjs/spec/createProgramFromSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createProgramFromSource.d.ts","sourceRoot":"","sources":["../../../spec/createProgramFromSource.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAwCjC,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,EAAE,CAAC,OAAO,CAAC;AACpE,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,EAAE,CAAC,OAAO,CAAC;AACtF,wBAAgB,uBAAuB,CAAC,OAAO,EAAE;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC"}

package/dist/commonjs/spec/createProgramFromSource.js

@@ -0,0 +1,111 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProgramFromSource = void 0;
+const ts = __importStar(require("typescript"));
+const path_1 = __importDefault(require("path"));
+const common_tags_1 = require("common-tags");
+function getConfig() {
+    const tsconfigPath = ts.findConfigFile('.', ts.sys.fileExists) || '';
+    const basePath = path_1.default.dirname(tsconfigPath);
+    const { config } = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+    const { options } = ts.parseJsonConfigFileContent(config, ts.sys, basePath, {}, tsconfigPath);
+    return options;
+}
+const styleSource = `
+export type CsVarsMap<T extends string, ID extends string | never> = [ID] extends [never]
+  ? Record<T, string>
+  : {[K in T]: \`--\${ID}-\${K}\`};
+
+export type CsVars<T extends string, ID extends string | never> = CsVarsMap<T, ID> & {
+  (input: Partial<Record<T, string>>): Record<T, string>;
+};
+export function createVars<T extends string, ID extends string>(input: {
+  id: ID;
+  args: T[];
+}): CsVars<T, ID>;
+export function createVars<T extends string>(...args: T[]): CsVars<T, never>;
+export function createVars<T extends string, ID extends string>(...args: T[]): CsVars<T, ID>;
+export function cssVar(input: string): string;
+export function createStyles(...args: any[]): string;
+`;
+function getLocalFileName(sources, name) {
+    var _a;
+    return (_a = sources.find(file => file.filename === name.replace(path_1.default.resolve(__dirname, '../../..') + '/', ''))) === null || _a === void 0 ? void 0 : _a.filename;
+}
+function createProgramFromSource(...args) {
+    let sources;
+    if (args.length === 2) {
+        sources = [{ filename: args[0], source: args[1] }];
+    }
+    else if (typeof args[0] === 'string') {
+        sources = [{ filename: 'test.ts', source: args[0] }];
+    }
+    else {
+        sources = args[0];
+    }
+    const sourceFiles = sources.map(({ filename, source }) => {
+        return ts.createSourceFile(filename, (0, common_tags_1.stripIndent)(source), ts.ScriptTarget.Latest);
+    });
+    sourceFiles.push(ts.createSourceFile('node_modules/@workday/canvas-kit-styling/index.ts', styleSource, ts.ScriptTarget.Latest));
+    const config = getConfig();
+    const customCompilerHost = {
+        getSourceFile: (name, languageVersion) => {
+            // Get the file from our mock list, but read source lib files
+            const mockedFile = sourceFiles.find(s => s.fileName === getLocalFileName(sources, name));
+            if (mockedFile) {
+                return mockedFile;
+            }
+            if (name.startsWith('lib')) {
+                return ts.createSourceFile(name, ts.sys.readFile(`node_modules/typescript/lib/${name}`), languageVersion);
+            }
+            const fileContents = ts.sys.readFile(name);
+            if (fileContents) {
+                return ts.createSourceFile(name, fileContents, languageVersion);
+            }
+            return undefined;
+        },
+        // eslint-disable-next-line no-empty-function
+        writeFile: () => { },
+        getDefaultLibFileName: () => 'lib.d.ts',
+        useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames,
+        getCanonicalFileName: fileName => ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
+        getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+        getNewLine: () => ts.sys.newLine,
+        getDirectories: path => ts.sys.getDirectories(path),
+        // This should be kept up to date with getSourceFile()
+        fileExists: fileName => {
+            return (sourceFiles.some(s => s.fileName === getLocalFileName(sources, fileName)) ||
+                ts.sys.fileExists(fileName));
+        },
+        readFile: fileName => ts.sys.readFile(fileName),
+    };
+    const program = ts.createProgram(sources.map(s => s.filename), config, customCompilerHost);
+    return program;
+}
+exports.createProgramFromSource = createProgramFromSource;

package/dist/commonjs/spec/findNodes.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+export declare function findNodes<N extends (node: ts.Node) => boolean>(node: ts.Node, name?: string, predicate?: N): (N extends (node: any) => node is infer S ? S[] : ts.Node[]) | undefined;
+//# sourceMappingURL=findNodes.d.ts.map

package/dist/commonjs/spec/findNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findNodes.d.ts","sourceRoot":"","sources":["../../../spec/findNodes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAU5B,wBAAgB,SAAS,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,OAAO,EAC5D,IAAI,EAAE,EAAE,CAAC,IAAI,EACb,IAAI,GAAE,MAAW,EACjB,SAAS,CAAC,EAAE,CAAC,GACZ,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,SAAS,CAoB1E"}

package/dist/commonjs/spec/findNodes.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNodes = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+function matchesName(node, name) {
+    var _a, _b;
+    return ((typescript_1.default.isIdentifier(node) && node.text === name) ||
+        ((_a = node === null || node === void 0 ? void 0 : node.name) === null || _a === void 0 ? void 0 : _a.text) === name || // declarations
+        ((_b = node === null || node === void 0 ? void 0 : node.expression) === null || _b === void 0 ? void 0 : _b.text) // expressions
+    );
+}
+function findNodes(node, name = '', predicate) {
+    const nodes = [];
+    if (!node) {
+        return nodes;
+    }
+    if ((predicate ? predicate(node) : true) && (name ? matchesName(node, name) : true)) {
+        nodes.push(node);
+    }
+    node.forEachChild(child => {
+        // The AST doesn't have parent nodes, but they are required for testing purposes.
+        child.parent = node;
+        const childNodes = findNodes(child, name, predicate);
+        if (childNodes) {
+            nodes.push(...childNodes);
+        }
+    });
+    return nodes;
+}
+exports.findNodes = findNodes;

package/dist/commonjs/testing.d.ts

@@ -0,0 +1,4 @@
+export { createProgramFromSource } from './spec/createProgramFromSource';
+export { transform, _reset, withDefaultContext } from './lib/styleTransform';
+export { findNodes } from './spec/findNodes';
+//# sourceMappingURL=testing.d.ts.map

package/dist/commonjs/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../../testing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,uBAAuB,EAAC,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAC,SAAS,EAAE,MAAM,EAAE,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AAC3E,OAAO,EAAC,SAAS,EAAC,MAAM,kBAAkB,CAAC"}

package/dist/commonjs/testing.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNodes = exports.withDefaultContext = exports._reset = exports.transform = exports.createProgramFromSource = void 0;
+var createProgramFromSource_1 = require("./spec/createProgramFromSource");
+Object.defineProperty(exports, "createProgramFromSource", { enumerable: true, get: function () { return createProgramFromSource_1.createProgramFromSource; } });
+var styleTransform_1 = require("./lib/styleTransform");
+Object.defineProperty(exports, "transform", { enumerable: true, get: function () { return styleTransform_1.transform; } });
+Object.defineProperty(exports, "_reset", { enumerable: true, get: function () { return styleTransform_1._reset; } });
+Object.defineProperty(exports, "withDefaultContext", { enumerable: true, get: function () { return styleTransform_1.withDefaultContext; } });
+var findNodes_1 = require("./spec/findNodes");
+Object.defineProperty(exports, "findNodes", { enumerable: true, get: function () { return findNodes_1.findNodes; } });

package/dist/es6/index.d.ts

@@ -0,0 +1,14 @@
+import styleTransformer from './lib/styleTransform';
+import type { Config } from './lib/utils/types';
+export type * from './lib/utils/types';
+export { parseNodeToStaticValue } from './lib/utils/parseNodeToStaticValue';
+export { parseObjectToStaticValue } from './lib/utils/parseObjectToStaticValue';
+export { createObjectTransform } from './lib/createObjectTransform';
+export { createPropertyTransform } from './lib/createPropertyTransform';
+export { styleTransformer };
+export { withDefaultContext } from './lib/styleTransform';
+export { getClassName } from './lib/utils/handleCreateStencil';
+export { StylingWebpackPlugin } from './lib/webpackPlugin';
+export default styleTransformer;
+export declare function createConfig(config: Config): Config;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AAE9C,mBAAmB,mBAAmB,CAAC;AACvC,OAAO,EAAC,sBAAsB,EAAC,MAAM,oCAAoC,CAAC;AAC1E,OAAO,EAAC,wBAAwB,EAAC,MAAM,sCAAsC,CAAC;AAC9E,OAAO,EAAC,qBAAqB,EAAC,MAAM,6BAA6B,CAAC;AAClE,OAAO,EAAC,uBAAuB,EAAC,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAC,gBAAgB,EAAC,CAAC;AAC1B,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAAC,YAAY,EAAC,MAAM,iCAAiC,CAAC;AAC7D,OAAO,EAAC,oBAAoB,EAAC,MAAM,qBAAqB,CAAC;AAGzD,eAAe,gBAAgB,CAAC;AAEhC,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/dist/es6/index.js

@@ -0,0 +1,14 @@
+import styleTransformer from './lib/styleTransform';
+export { parseNodeToStaticValue } from './lib/utils/parseNodeToStaticValue';
+export { parseObjectToStaticValue } from './lib/utils/parseObjectToStaticValue';
+export { createObjectTransform } from './lib/createObjectTransform';
+export { createPropertyTransform } from './lib/createPropertyTransform';
+export { styleTransformer };
+export { withDefaultContext } from './lib/styleTransform';
+export { getClassName } from './lib/utils/handleCreateStencil';
+export { StylingWebpackPlugin } from './lib/webpackPlugin';
+// be compatible with ts-patch which expects a default export
+export default styleTransformer;
+export function createConfig(config) {
+    return config;
+}

package/dist/es6/lib/createObjectTransform.d.ts

@@ -0,0 +1,10 @@
+import { ObjectTransform } from './utils/types';
+/**
+ * Object transforms take an AST node that represents a style object and turn it into a
+ * `NestedStyleObject` or return `void`. If an object transform returns an object, transformation
+ * parsing stops on that node. If `void` is returned, processing continues using
+ * `parseObjectToStaticValue`. These transforms are useful if you have custom utility functions
+ * that are not statically parsable by the static styling transformer.
+ */
+export declare function createObjectTransform(transformFn: ObjectTransform): ObjectTransform;
+//# sourceMappingURL=createObjectTransform.d.ts.map

package/dist/es6/lib/createObjectTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createObjectTransform.d.ts","sourceRoot":"","sources":["../../../lib/createObjectTransform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,eAAe,CAAC;AAE9C;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,eAAe,GAAG,eAAe,CAEnF"}

package/dist/es6/lib/createObjectTransform.js

@@ -0,0 +1,10 @@
+/**
+ * Object transforms take an AST node that represents a style object and turn it into a
+ * `NestedStyleObject` or return `void`. If an object transform returns an object, transformation
+ * parsing stops on that node. If `void` is returned, processing continues using
+ * `parseObjectToStaticValue`. These transforms are useful if you have custom utility functions
+ * that are not statically parsable by the static styling transformer.
+ */
+export function createObjectTransform(transformFn) {
+    return transformFn;
+}

package/dist/es6/lib/createPropertyTransform.d.ts

@@ -0,0 +1,7 @@
+import { PropertyTransform } from './utils/types';
+/**
+ * A property transform takes a style property node and will return a string. You can use
+ * `parseNodeToStaticValue` to help you process properties that might be inputs to a function.
+ */
+export declare function createPropertyTransform(transformFn: PropertyTransform): PropertyTransform;
+//# sourceMappingURL=createPropertyTransform.d.ts.map

package/dist/es6/lib/createPropertyTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createPropertyTransform.d.ts","sourceRoot":"","sources":["../../../lib/createPropertyTransform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,iBAAiB,EAAC,MAAM,eAAe,CAAC;AAEhD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,iBAAiB,GAAG,iBAAiB,CAEzF"}