@atlaspack/transformer-postcss 2.14.5-canary.39 → 2.14.5-canary.391

package/dist/PostCSSTransformer.js

@@ -0,0 +1,281 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const rust_1 = require("@atlaspack/rust");
+const utils_1 = require("@atlaspack/utils");
+const plugin_1 = require("@atlaspack/plugin");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const path_1 = __importDefault(require("path"));
+const semver_1 = __importDefault(require("semver"));
+const postcss_value_parser_1 = __importDefault(require("postcss-value-parser"));
+const loadConfig_1 = require("./loadConfig");
+const constants_1 = require("./constants");
+const diagnostic_1 = require("@atlaspack/diagnostic");
+const COMPOSES_RE = /composes:.+from\s*("|').*("|')\s*;?/;
+const FROM_IMPORT_RE = /.+from\s*(?:"|')(.*)(?:"|')\s*;?/;
+const LEGACY_MODULE_RE = /@value|:export|(:global|:local|:import)(?!\s*\()/i;
+const MODULE_BY_NAME_RE = /\.module\./;
+exports.default = new plugin_1.Transformer({
+    loadConfig({ config, options, logger }) {
+        return (0, loadConfig_1.load)({ config, options, logger });
+    },
+    canReuseAST({ ast }) {
+        return (ast.type === 'postcss' && semver_1.default.satisfies(ast.version, constants_1.POSTCSS_RANGE));
+    },
+    async parse({ asset, config, options }) {
+        let isLegacy = await isLegacyCssModule(asset);
+        if (!config && !isLegacy) {
+            return;
+        }
+        const postcss = await loadPostcss(options, asset.filePath);
+        return {
+            type: 'postcss',
+            version: '8.2.1',
+            program: postcss
+                .parse(await asset.getCode(), {
+                from: asset.filePath,
+            })
+                .toJSON(),
+        };
+    },
+    async transform({ asset, config, options, resolve, logger }) {
+        asset.type = 'css';
+        let isLegacy = await isLegacyCssModule(asset);
+        if (isLegacy && !config) {
+            config = {
+                raw: {},
+                filePath: '',
+                hydrated: {
+                    plugins: [],
+                    from: asset.filePath,
+                    to: asset.filePath,
+                    modules: {},
+                },
+            };
+            // TODO: warning?
+        }
+        if (!config) {
+            return [asset];
+        }
+        // @ts-expect-error TS2709
+        const postcss = await loadPostcss(options, asset.filePath);
+        let ast = (0, nullthrows_1.default)(await asset.getAST());
+        let program = postcss.fromJSON(ast.program);
+        let plugins = [...config.hydrated.plugins];
+        let cssModules = null;
+        if (config.hydrated.modules) {
+            asset.meta.cssModulesCompiled = 'postcss';
+            let code = asset.isASTDirty() ? null : await asset.getCode();
+            if (Object.keys(config.hydrated.modules).length === 0 &&
+                code &&
+                !isLegacy &&
+                !LEGACY_MODULE_RE.test(code)) {
+                let filename = path_1.default.basename(config.filePath);
+                let message;
+                let configKey;
+                let hint;
+                if (config.raw.modules) {
+                    message = (0, diagnostic_1.md) `The "modules" option in __${filename}__ can be replaced with configuration for @atlaspack/transformer-css to improve build performance.`;
+                    configKey = '/modules';
+                    hint = (0, diagnostic_1.md) `Remove the "modules" option from __${filename}__`;
+                }
+                else {
+                    message = (0, diagnostic_1.md) `The "postcss-modules" plugin in __${filename}__ can be replaced with configuration for @atlaspack/transformer-css to improve build performance.`;
+                    configKey = '/plugins/postcss-modules';
+                    hint = (0, diagnostic_1.md) `Remove the "postcss-modules" plugin from __${filename}__`;
+                }
+                if (filename === 'package.json') {
+                    configKey = `/postcss${configKey}`;
+                }
+                let hints = [
+                    'Enable the "cssModules" option for "@atlaspack/transformer-css" in your package.json',
+                ];
+                if (plugins.length === 0) {
+                    message += (0, diagnostic_1.md) ` Since there are no other plugins, __${filename}__ can be deleted safely.`;
+                    hints.push((0, diagnostic_1.md) `Delete __${filename}__`);
+                }
+                else {
+                    hints.push(hint);
+                }
+                let codeFrames;
+                if (path_1.default.extname(filename) !== '.js') {
+                    let contents = await asset.fs.readFile(config.filePath, 'utf8');
+                    codeFrames = [
+                        {
+                            language: 'json',
+                            filePath: config.filePath,
+                            code: contents,
+                            codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(contents, [
+                                {
+                                    key: configKey,
+                                    type: 'key',
+                                },
+                            ]),
+                        },
+                    ];
+                }
+                else {
+                    codeFrames = [
+                        {
+                            filePath: config.filePath,
+                            codeHighlights: [
+                                {
+                                    start: { line: 1, column: 1 },
+                                    end: { line: 1, column: 1 },
+                                },
+                            ],
+                        },
+                    ];
+                }
+                logger.warn({
+                    message,
+                    hints,
+                    documentationURL: 'https://parceljs.org/languages/css/#enabling-css-modules-globally',
+                    codeFrames,
+                });
+            }
+            // TODO: should this be resolved from the project root?
+            let postcssModules = await options.packageManager.require('postcss-modules', asset.filePath, {
+                range: '^4.3.0',
+                saveDev: true,
+                shouldAutoInstall: options.shouldAutoInstall,
+            });
+            plugins.push(postcssModules({
+                // @ts-expect-error TS7006
+                getJSON: (filename, json) => (cssModules = json),
+                Loader: await createLoader(asset, resolve, options),
+                // @ts-expect-error TS7006
+                generateScopedName: (name, filename) => `${name}_${(0, rust_1.hashString)(path_1.default.relative(options.projectRoot, filename)).substr(0, 6)}`,
+                ...config.hydrated.modules,
+            }));
+            if (code == null || COMPOSES_RE.test(code)) {
+                // @ts-expect-error TS7006
+                program.walkDecls((decl) => {
+                    let [, importPath] = FROM_IMPORT_RE.exec(decl.value) || [];
+                    if (decl.prop === 'composes' && importPath != null) {
+                        let parsed = (0, postcss_value_parser_1.default)(decl.value);
+                        parsed.walk((node) => {
+                            if (node.type === 'string') {
+                                asset.addDependency({
+                                    specifier: importPath,
+                                    specifierType: 'url',
+                                    loc: {
+                                        filePath: asset.filePath,
+                                        start: decl.source.start,
+                                        end: {
+                                            line: decl.source.start.line,
+                                            column: decl.source.start.column + importPath.length,
+                                        },
+                                    },
+                                });
+                            }
+                        });
+                    }
+                });
+            }
+        }
+        let { messages, root } = await postcss(plugins).process(program, config.hydrated);
+        asset.setAST({
+            type: 'postcss',
+            version: '8.2.1',
+            program: root.toJSON(),
+        });
+        for (let msg of messages) {
+            if (msg.type === 'dependency') {
+                asset.invalidateOnFileChange(msg.file);
+            }
+            else if (msg.type === 'dir-dependency') {
+                let pattern = `${msg.dir}/${msg.glob ?? '**/*'}`;
+                let files = await (0, utils_1.glob)(pattern, asset.fs, { onlyFiles: true });
+                for (let file of files) {
+                    asset.invalidateOnFileChange(path_1.default.normalize(file));
+                }
+                asset.invalidateOnFileCreate({ glob: pattern });
+            }
+        }
+        let assets = [asset];
+        if (cssModules) {
+            let cssModulesList = Object.entries(cssModules);
+            let deps = asset
+                .getDependencies()
+                .filter((dep) => dep.priority === 'sync');
+            let code;
+            if (deps.length > 0) {
+                code = `
+          module.exports = Object.assign({}, ${deps
+                    .map((dep) => `require(${JSON.stringify(dep.specifier)})`)
+                    .join(', ')}, ${JSON.stringify(cssModules, null, 2)});
+        `;
+            }
+            else {
+                code = cssModulesList
+                    .map(
+                // This syntax enables shaking the invidual statements, so that unused classes don't even exist in JS.
+                ([className, classNameHashed]) => `module.exports[${JSON.stringify(className)}] = ${JSON.stringify(classNameHashed)};`)
+                    .join('\n');
+            }
+            asset.symbols.ensure();
+            for (let [k, v] of cssModulesList) {
+                asset.symbols.set(k, v);
+            }
+            asset.symbols.set('default', 'default');
+            assets.push({
+                type: 'js',
+                // @ts-expect-error TS2353
+                content: code,
+            });
+        }
+        return assets;
+    },
+    async generate({ asset, ast, options }) {
+        // @ts-expect-error TS2709
+        const postcss = await loadPostcss(options, asset.filePath);
+        let code = '';
+        // @ts-expect-error TS7006
+        postcss.stringify(postcss.fromJSON(ast.program), (c) => {
+            code += c;
+        });
+        return {
+            content: code,
+        };
+    },
+});
+async function createLoader(asset, resolve, options) {
+    let { default: FileSystemLoader } = await options.packageManager.require('postcss-modules/build/css-loader-core/loader', asset.filePath);
+    return class AtlaspackFileSystemLoader extends FileSystemLoader {
+        async fetch(composesPath, relativeTo) {
+            let importPath = composesPath.replace(/^["']|["']$/g, '');
+            let resolved = await resolve(relativeTo, importPath);
+            let rootRelativePath = path_1.default.resolve(path_1.default.dirname(relativeTo), resolved);
+            let root = path_1.default.resolve('/');
+            // fixes an issue on windows which is part of the css-modules-loader-core
+            // see https://github.com/css-modules/css-modules-loader-core/issues/230
+            if (rootRelativePath.startsWith(root)) {
+                rootRelativePath = rootRelativePath.substr(root.length);
+            }
+            let source = await asset.fs.readFile(resolved, 'utf-8');
+            let { exportTokens } = await this.core.load(source, rootRelativePath, undefined, this.fetch.bind(this));
+            return exportTokens;
+        }
+        get finalSource() {
+            return '';
+        }
+    };
+}
+// @ts-expect-error TS2709
+function loadPostcss(options, from) {
+    return options.packageManager.require('postcss', from, {
+        range: constants_1.POSTCSS_RANGE,
+        saveDev: true,
+        shouldAutoInstall: options.shouldAutoInstall,
+    });
+}
+async function isLegacyCssModule(asset) {
+    if (!MODULE_BY_NAME_RE.test(asset.filePath)) {
+        return false;
+    }
+    let code = await asset.getCode();
+    return LEGACY_MODULE_RE.test(code);
+}

package/dist/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POSTCSS_RANGE = void 0;
+exports.POSTCSS_RANGE = '^8.2.1';

package/dist/loadConfig.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = load;
+const path_1 = __importDefault(require("path"));
+const diagnostic_1 = require("@atlaspack/diagnostic");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+// @ts-expect-error TS7016
+const clone_1 = __importDefault(require("clone"));
+const constants_1 = require("./constants");
+const loadPlugins_1 = __importDefault(require("./loadPlugins"));
+async function configHydrator(configFile, config, resolveFrom, options, logger) {
+    if (configFile == null) {
+        return;
+    }
+    // Load the custom config...
+    let modulesConfig;
+    let configFilePlugins = (0, clone_1.default)(configFile.plugins);
+    if (configFilePlugins != null &&
+        typeof configFilePlugins === 'object' &&
+        configFilePlugins['postcss-modules'] != null) {
+        modulesConfig = configFilePlugins['postcss-modules'];
+        delete configFilePlugins['postcss-modules'];
+    }
+    if (!modulesConfig && configFile.modules) {
+        modulesConfig = {};
+    }
+    let plugins = await (0, loadPlugins_1.default)(configFilePlugins, (0, nullthrows_1.default)(resolveFrom), options);
+    // contents is either:
+    // from JSON:    { plugins: { 'postcss-foo': { ...opts } } }
+    // from JS (v8): { plugins: [ { postcssPlugin: 'postcss-foo', ...visitor callback functions } ]
+    // from JS (v7): { plugins: [ [Function: ...] ]
+    let pluginArray = Array.isArray(configFilePlugins)
+        ? configFilePlugins
+        : Object.keys(configFilePlugins);
+    for (let p of pluginArray) {
+        if (typeof p === 'string') {
+            config.addDevDependency({
+                specifier: p,
+                resolveFrom: (0, nullthrows_1.default)(resolveFrom),
+            });
+        }
+    }
+    let redundantPlugins = pluginArray.filter((p) => p === 'autoprefixer' || p === 'postcss-preset-env');
+    if (redundantPlugins.length > 0) {
+        let filename = path_1.default.basename(resolveFrom);
+        let isPackageJson = filename === 'package.json';
+        let message;
+        let hints = [];
+        if (!isPackageJson && redundantPlugins.length === pluginArray.length) {
+            message = (0, diagnostic_1.md) `Parcel includes CSS transpilation and vendor prefixing by default. PostCSS config __${filename}__ contains only redundant plugins. Deleting it may significantly improve build performance.`;
+            hints.push((0, diagnostic_1.md) `Delete __${filename}__`);
+        }
+        else {
+            message = (0, diagnostic_1.md) `Parcel includes CSS transpilation and vendor prefixing by default. PostCSS config __${filename}__ contains the following redundant plugins: ${[
+                ...redundantPlugins,
+            ].map((p) => diagnostic_1.md.underline(p))}. Removing these may improve build performance.`;
+            hints.push((0, diagnostic_1.md) `Remove the above plugins from __${filename}__`);
+        }
+        let codeFrames;
+        if (path_1.default.extname(filename) !== '.js') {
+            let contents = await options.inputFS.readFile(resolveFrom, 'utf8');
+            let prefix = isPackageJson ? '/postcss' : '';
+            codeFrames = [
+                {
+                    language: 'json',
+                    filePath: resolveFrom,
+                    code: contents,
+                    codeHighlights: (0, diagnostic_1.generateJSONCodeHighlights)(contents, redundantPlugins.map((plugin) => ({
+                        key: `${prefix}/plugins/${plugin}`,
+                        type: 'key',
+                    }))),
+                },
+            ];
+        }
+        else {
+            codeFrames = [
+                {
+                    filePath: resolveFrom,
+                    codeHighlights: [
+                        {
+                            start: { line: 1, column: 1 },
+                            end: { line: 1, column: 1 },
+                        },
+                    ],
+                },
+            ];
+        }
+        logger.warn({
+            message,
+            hints,
+            documentationURL: 'https://parceljs.org/languages/css/#default-plugins',
+            codeFrames,
+        });
+    }
+    return {
+        raw: configFile,
+        filePath: resolveFrom,
+        hydrated: {
+            plugins,
+            from: config.searchPath,
+            to: config.searchPath,
+            modules: modulesConfig,
+        },
+    };
+}
+async function load({ config, options, logger, }) {
+    if (!config.isSource) {
+        return;
+    }
+    let configFile = await config.getConfig([
+        '.postcssrc',
+        '.postcssrc.json',
+        '.postcssrc.js',
+        '.postcssrc.cjs',
+        '.postcssrc.mjs',
+        'postcss.config.js',
+        'postcss.config.cjs',
+        'postcss.config.mjs',
+    ], { packageKey: 'postcss' });
+    let contents = null;
+    if (configFile) {
+        config.addDevDependency({
+            specifier: 'postcss',
+            resolveFrom: config.searchPath,
+            range: constants_1.POSTCSS_RANGE,
+        });
+        contents = configFile.contents;
+        let isDynamic = configFile && path_1.default.extname(configFile.filePath).endsWith('js');
+        if (isDynamic) {
+            // We have to invalidate on startup in case the config is non-deterministic,
+            // e.g. using unknown environment variables, reading from the filesystem, etc.
+            logger.warn({
+                message: 'WARNING: Using a JavaScript PostCSS config file means losing out on caching features of Parcel. Use a .postcssrc(.json) file whenever possible.',
+            });
+        }
+        if (typeof contents !== 'object') {
+            throw new Error('PostCSS config should be an object.');
+        }
+        if (contents.plugins == null ||
+            typeof contents.plugins !== 'object' ||
+            Object.keys(contents.plugins).length === 0) {
+            throw new Error('PostCSS config must have plugins');
+        }
+    }
+    return configHydrator(contents, config, configFile?.filePath, options, logger);
+}

package/dist/loadPlugins.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loadExternalPlugins;
+async function loadExternalPlugins(plugins, relative, options) {
+    if (Array.isArray(plugins)) {
+        return Promise.all(plugins
+            .map((p) => loadPlugin(p, relative, null, options.packageManager, options.shouldAutoInstall))
+            .filter(Boolean));
+    }
+    else if (typeof plugins === 'object') {
+        let _plugins = plugins;
+        let mapPlugins = await Promise.all(Object.keys(plugins).map((p) => loadPlugin(p, relative, _plugins[p], options.packageManager, options.shouldAutoInstall)));
+        return mapPlugins.filter(Boolean);
+    }
+    else {
+        return [];
+    }
+}
+async function loadPlugin(pluginArg, relative, options = {}, packageManager, shouldAutoInstall) {
+    if (typeof pluginArg !== 'string') {
+        return pluginArg;
+    }
+    let plugin = await packageManager.require(pluginArg, relative, {
+        shouldAutoInstall,
+    });
+    plugin = plugin.default || plugin;
+    if (options != null &&
+        typeof options === 'object' &&
+        Object.keys(options).length > 0) {
+        plugin = plugin(options);
+    }
+    return plugin.default || plugin;
+}

package/lib/PostCSSTransformer.js

@@ -129,6 +129,8 @@ var _default = exports.default = new (_plugin().Transformer)({
     if (!config) {
       return [asset];
     }
+
+    // @ts-expect-error TS2709
     const postcss = await loadPostcss(options, asset.filePath);
     let ast = (0, _nullthrows().default)(await asset.getAST());
     let program = postcss.fromJSON(ast.program);
@@ -203,12 +205,15 @@ var _default = exports.default = new (_plugin().Transformer)({
         shouldAutoInstall: options.shouldAutoInstall
       });
       plugins.push(postcssModules({
+        // @ts-expect-error TS7006
         getJSON: (filename, json) => cssModules = json,
         Loader: await createLoader(asset, resolve, options),
+        // @ts-expect-error TS7006
         generateScopedName: (name, filename) => `${name}_${(0, _rust().hashString)(_path().default.relative(options.projectRoot, filename)).substr(0, 6)}`,
         ...config.hydrated.modules
       }));
       if (code == null || COMPOSES_RE.test(code)) {
+        // @ts-expect-error TS7006
         program.walkDecls(decl => {
           let [, importPath] = FROM_IMPORT_RE.exec(decl.value) || [];
           if (decl.prop === 'composes' && importPath != null) {
@@ -233,8 +238,6 @@ var _default = exports.default = new (_plugin().Transformer)({
         });
       }
     }
-
-    // $FlowFixMe Added in Flow 0.121.0 upgrade in #4381
     let {
       messages,
       root
@@ -262,7 +265,6 @@ var _default = exports.default = new (_plugin().Transformer)({
     }
     let assets = [asset];
     if (cssModules) {
-      // $FlowFixMe
       let cssModulesList = Object.entries(cssModules);
       let deps = asset.getDependencies().filter(dep => dep.priority === 'sync');
       let code;
@@ -282,6 +284,7 @@ var _default = exports.default = new (_plugin().Transformer)({
       asset.symbols.set('default', 'default');
       assets.push({
         type: 'js',
+        // @ts-expect-error TS2353
         content: code
       });
     }
@@ -292,8 +295,10 @@ var _default = exports.default = new (_plugin().Transformer)({
     ast,
     options
   }) {
+    // @ts-expect-error TS2709
     const postcss = await loadPostcss(options, asset.filePath);
     let code = '';
+    // @ts-expect-error TS7006
     postcss.stringify(postcss.fromJSON(ast.program), c => {
       code += c;
     });
@@ -306,7 +311,7 @@ async function createLoader(asset, resolve, options) {
   let {
     default: FileSystemLoader
   } = await options.packageManager.require('postcss-modules/build/css-loader-core/loader', asset.filePath);
-  return class extends FileSystemLoader {
+  return class AtlaspackFileSystemLoader extends FileSystemLoader {
     async fetch(composesPath, relativeTo) {
       let importPath = composesPath.replace(/^["']|["']$/g, '');
       let resolved = await resolve(relativeTo, importPath);
@@ -320,9 +325,7 @@ async function createLoader(asset, resolve, options) {
       let source = await asset.fs.readFile(resolved, 'utf-8');
       let {
         exportTokens
-      } = await this.core.load(source, rootRelativePath, undefined,
-      // $FlowFixMe[method-unbinding]
-      this.fetch.bind(this));
+      } = await this.core.load(source, rootRelativePath, undefined, this.fetch.bind(this));
       return exportTokens;
     }
     get finalSource() {
@@ -330,6 +333,8 @@ async function createLoader(asset, resolve, options) {
     }
   };
 }
+
+// @ts-expect-error TS2709
 function loadPostcss(options, from) {
   return options.packageManager.require('postcss', from, {
     range: _constants.POSTCSS_RANGE,

package/lib/loadConfig.js

@@ -35,6 +35,8 @@ function _clone() {
 var _constants = require("./constants");
 var _loadPlugins = _interopRequireDefault(require("./loadPlugins"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// @ts-expect-error TS7016
+
 async function configHydrator(configFile, config, resolveFrom, options, logger) {
   if (configFile == null) {
     return;

package/lib/loadPlugins.js

@@ -8,13 +8,16 @@ async function loadExternalPlugins(plugins, relative, options) {
   if (Array.isArray(plugins)) {
     return Promise.all(plugins.map(p => loadPlugin(p, relative, null, options.packageManager, options.shouldAutoInstall)).filter(Boolean));
   } else if (typeof plugins === 'object') {
-    let mapPlugins = await Promise.all(Object.keys(plugins).map(p => loadPlugin(p, relative, plugins[p], options.packageManager, options.shouldAutoInstall)));
+    let _plugins = plugins;
+    let mapPlugins = await Promise.all(Object.keys(plugins).map(p => loadPlugin(p, relative, _plugins[p], options.packageManager, options.shouldAutoInstall)));
     return mapPlugins.filter(Boolean);
   } else {
     return [];
   }
 }
-async function loadPlugin(pluginArg, relative, options = {}, packageManager, shouldAutoInstall) {
+async function loadPlugin(pluginArg, relative, options = {}, packageManager, shouldAutoInstall
+// @ts-expect-error TS1064
+) {
   if (typeof pluginArg !== 'string') {
     return pluginArg;
   }

package/lib/types/PostCSSTransformer.d.ts

@@ -0,0 +1,3 @@
+import { Transformer } from '@atlaspack/plugin';
+declare const _default: Transformer<unknown>;
+export default _default;

package/lib/types/constants.d.ts

@@ -0,0 +1 @@
+export declare const POSTCSS_RANGE = "^8.2.1";

package/lib/types/loadConfig.d.ts

@@ -0,0 +1,17 @@
+import type { Config, FilePath, PluginOptions, PluginLogger } from '@atlaspack/types-internal';
+type ConfigResult = {
+    raw: any;
+    filePath: string;
+    hydrated: {
+        plugins: Array<any>;
+        from: FilePath;
+        to: FilePath;
+        modules: any;
+    };
+};
+export declare function load({ config, options, logger, }: {
+    config: Config;
+    options: PluginOptions;
+    logger: PluginLogger;
+}): Promise<ConfigResult | null | undefined>;
+export {};

package/lib/types/loadPlugins.d.ts

@@ -0,0 +1,4 @@
+import type { FilePath, PluginOptions } from '@atlaspack/types-internal';
+export default function loadExternalPlugins(plugins: Array<string> | {
+    readonly [pluginName: string]: unknown;
+}, relative: FilePath, options: PluginOptions): Promise<Array<unknown>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/transformer-postcss",
-  "version": "2.14.5-canary.39+42a775de8",
+  "version": "2.14.5-canary.391+053e3754c",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -9,16 +9,18 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/PostCSSTransformer.js",
-  "source": "src/PostCSSTransformer.js",
+  "main": "./lib/PostCSSTransformer.js",
+  "source": "./src/PostCSSTransformer.ts",
+  "types": "./lib/types/PostCSSTransformer.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.1-canary.107+42a775de8",
-    "@atlaspack/plugin": "2.14.5-canary.39+42a775de8",
-    "@atlaspack/rust": "3.2.1-canary.39+42a775de8",
-    "@atlaspack/utils": "2.14.5-canary.39+42a775de8",
+    "@atlaspack/diagnostic": "2.14.1-canary.459+053e3754c",
+    "@atlaspack/plugin": "2.14.5-canary.391+053e3754c",
+    "@atlaspack/rust": "3.2.1-canary.391+053e3754c",
+    "@atlaspack/types-internal": "2.14.1-canary.459+053e3754c",
+    "@atlaspack/utils": "2.14.5-canary.391+053e3754c",
     "clone": "^2.1.1",
     "nullthrows": "^1.1.1",
     "postcss-value-parser": "^4.2.0",
@@ -29,5 +31,8 @@
     "postcss-modules": "^4.3.1"
   },
   "type": "commonjs",
-  "gitHead": "42a775de8eec638ad188f3271964170d8c04d84b"
-}
+  "scripts": {
+    "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
+  },
+  "gitHead": "053e3754c08c5b5dc239e9f7267df289cbbf31ab"
+}