@lwc/babel-plugin-component 2.41.3 → 2.43.0

package/src/decorators/wire/transform.js

@@ -1,261 +0,0 @@
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-const { LWC_COMPONENT_PROPERTIES } = require('../../constants');
-
-const { isWireDecorator } = require('./shared');
-
-const WIRE_PARAM_PREFIX = '$';
-const WIRE_CONFIG_ARG_NAME = '$cmp';
-
-function isObservedProperty(configProperty) {
-    const propertyValue = configProperty.get('value');
-    return (
-        propertyValue.isStringLiteral() && propertyValue.node.value.startsWith(WIRE_PARAM_PREFIX)
-    );
-}
-
-function getWiredStatic(wireConfig) {
-    return wireConfig
-        .get('properties')
-        .filter((property) => !isObservedProperty(property))
-        .map((path) => path.node);
-}
-
-function getWiredParams(t, wireConfig) {
-    return wireConfig
-        .get('properties')
-        .filter((property) => isObservedProperty(property))
-        .map((path) => {
-            // Need to clone deep the observed property to remove the param prefix
-            const clonedProperty = t.cloneDeep(path.node);
-            clonedProperty.value.value = clonedProperty.value.value.slice(1);
-
-            return clonedProperty;
-        });
-}
-
-function getGeneratedConfig(t, wiredValue) {
-    let counter = 0;
-    const configBlockBody = [];
-    const configProps = [];
-    const generateParameterConfigValue = (memberExprPaths) => {
-        // Note: When memberExprPaths ($foo.bar) has an invalid identifier (eg: foo..bar, foo.bar[3])
-        //       it should (ideally) resolve in a compilation error during validation phase.
-        //       This is not possible due that platform components may have a param definition which is invalid
-        //       but passes compilation, and throwing at compile time would break such components.
-        //       In such cases where the param does not have proper notation, the config generated will use the bracket
-        //       notation to match the current behavior (that most likely end up resolving that param as undefined).
-        const isInvalidMemberExpr = memberExprPaths.some(
-            (maybeIdentifier) =>
-                !(t.isValidES3Identifier(maybeIdentifier) && maybeIdentifier.length > 0)
-        );
-        const memberExprPropertyGen = !isInvalidMemberExpr ? t.identifier : t.StringLiteral;
-
-        if (memberExprPaths.length === 1) {
-            return {
-                configValueExpression: t.memberExpression(
-                    t.identifier(WIRE_CONFIG_ARG_NAME),
-                    memberExprPropertyGen(memberExprPaths[0])
-                ),
-            };
-        }
-
-        const varName = 'v' + ++counter;
-        const varDeclaration = t.variableDeclaration('let', [
-            t.variableDeclarator(
-                t.identifier(varName),
-                t.memberExpression(
-                    t.identifier(WIRE_CONFIG_ARG_NAME),
-                    memberExprPropertyGen(memberExprPaths[0]),
-                    isInvalidMemberExpr
-                )
-            ),
-        ]);
-
-        // Results in: v != null && ... (v = v.i) != null && ... (v = v.(n-1)) != null
-        let conditionTest = t.binaryExpression('!=', t.identifier(varName), t.nullLiteral());
-
-        for (let i = 1, n = memberExprPaths.length; i < n - 1; i++) {
-            const nextPropValue = t.assignmentExpression(
-                '=',
-                t.identifier(varName),
-                t.memberExpression(
-                    t.identifier(varName),
-                    memberExprPropertyGen(memberExprPaths[i]),
-                    isInvalidMemberExpr
-                )
-            );
-
-            conditionTest = t.logicalExpression(
-                '&&',
-                conditionTest,
-                t.binaryExpression('!=', nextPropValue, t.nullLiteral())
-            );
-        }
-
-        // conditionTest ? v.n : undefined
-        const configValueExpression = t.conditionalExpression(
-            conditionTest,
-            t.memberExpression(
-                t.identifier(varName),
-                memberExprPropertyGen(memberExprPaths[memberExprPaths.length - 1]),
-                isInvalidMemberExpr
-            ),
-            t.identifier('undefined')
-        );
-
-        return {
-            varDeclaration,
-            configValueExpression,
-        };
-    };
-
-    if (wiredValue.static) {
-        Array.prototype.push.apply(configProps, wiredValue.static);
-    }
-
-    if (wiredValue.params) {
-        wiredValue.params.forEach((param) => {
-            const memberExprPaths = param.value.value.split('.');
-            const paramConfigValue = generateParameterConfigValue(memberExprPaths);
-
-            configProps.push(t.objectProperty(param.key, paramConfigValue.configValueExpression));
-
-            if (paramConfigValue.varDeclaration) {
-                configBlockBody.push(paramConfigValue.varDeclaration);
-            }
-        });
-    }
-
-    configBlockBody.push(t.returnStatement(t.objectExpression(configProps)));
-
-    const fnExpression = t.functionExpression(
-        null,
-        [t.identifier(WIRE_CONFIG_ARG_NAME)],
-        t.blockStatement(configBlockBody)
-    );
-
-    return t.objectProperty(t.identifier('config'), fnExpression);
-}
-
-function buildWireConfigValue(t, wiredValues) {
-    return t.objectExpression(
-        wiredValues.map((wiredValue) => {
-            const wireConfig = [];
-            if (wiredValue.adapter) {
-                wireConfig.push(
-                    t.objectProperty(t.identifier('adapter'), wiredValue.adapter.expression)
-                );
-            }
-
-            if (wiredValue.params) {
-                const dynamicParamNames = wiredValue.params.map((p) => {
-                    return t.stringLiteral(t.isIdentifier(p.key) ? p.key.name : p.key.value);
-                });
-                wireConfig.push(
-                    t.objectProperty(t.identifier('dynamic'), t.arrayExpression(dynamicParamNames))
-                );
-            }
-
-            if (wiredValue.isClassMethod) {
-                wireConfig.push(t.objectProperty(t.identifier('method'), t.numericLiteral(1)));
-            }
-
-            wireConfig.push(getGeneratedConfig(t, wiredValue));
-
-            return t.objectProperty(
-                t.identifier(wiredValue.propertyName),
-                t.objectExpression(wireConfig)
-            );
-        })
-    );
-}
-
-const SUPPORTED_VALUE_TO_TYPE_MAP = {
-    StringLiteral: 'string',
-    NumericLiteral: 'number',
-    BooleanLiteral: 'boolean',
-};
-
-const scopedReferenceLookup = (scope) => (name) => {
-    const binding = scope.getBinding(name);
-
-    let type;
-    let value;
-
-    if (binding) {
-        if (binding.kind === 'module') {
-            // Resolves module import to the name of the module imported
-            // e.g. import { foo } from 'bar' gives value 'bar' for `name == 'foo'
-            const parentPathNode = binding.path.parentPath.node;
-            if (parentPathNode && parentPathNode.source) {
-                type = 'module';
-                value = parentPathNode.source.value;
-            }
-        } else if (binding.kind === 'const') {
-            // Resolves `const foo = 'text';` references to value 'text', where `name == 'foo'`
-            const init = binding.path.node.init;
-            if (init && SUPPORTED_VALUE_TO_TYPE_MAP[init.type]) {
-                type = SUPPORTED_VALUE_TO_TYPE_MAP[init.type];
-                value = init.value;
-            }
-        }
-    }
-    return {
-        type,
-        value,
-    };
-};
-
-module.exports = function transform(t, decoratorMetas) {
-    const objectProperties = [];
-    const wiredValues = decoratorMetas.filter(isWireDecorator).map(({ path }) => {
-        const [id, config] = path.get('expression.arguments');
-
-        const propertyName = path.parentPath.get('key.name').node;
-        const isClassMethod = path.parentPath.isClassMethod({
-            kind: 'method',
-        });
-
-        const wiredValue = {
-            propertyName,
-            isClassMethod,
-        };
-
-        if (config) {
-            wiredValue.static = getWiredStatic(config);
-            wiredValue.params = getWiredParams(t, config);
-        }
-
-        const referenceLookup = scopedReferenceLookup(path.scope);
-        const isMemberExpression = id.isMemberExpression();
-        const isIdentifier = id.isIdentifier();
-
-        if (isIdentifier || isMemberExpression) {
-            const referenceName = isMemberExpression ? id.node.object.name : id.node.name;
-            const reference = referenceLookup(referenceName);
-            wiredValue.adapter = {
-                name: referenceName,
-                expression: t.cloneDeep(id.node),
-                reference: reference.type === 'module' ? reference.value : undefined,
-            };
-        }
-
-        return wiredValue;
-    });
-
-    if (wiredValues.length) {
-        objectProperties.push(
-            t.objectProperty(
-                t.identifier(LWC_COMPONENT_PROPERTIES.WIRE),
-                buildWireConfigValue(t, wiredValues)
-            )
-        );
-    }
-
-    return objectProperties;
-};

package/src/decorators/wire/validate.js

@@ -1,100 +0,0 @@
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-const { DecoratorErrors } = require('@lwc/errors');
-const {
-    LWC_PACKAGE_EXPORTS: { WIRE_DECORATOR, TRACK_DECORATOR, API_DECORATOR },
-} = require('../../constants');
-const { generateError } = require('../../utils');
-
-const { isWireDecorator } = require('./shared');
-
-function validateWireParameters(path) {
-    const [id, config] = path.get('expression.arguments');
-
-    if (!id) {
-        throw generateError(path, {
-            errorInfo: DecoratorErrors.ADAPTER_SHOULD_BE_FIRST_PARAMETER,
-        });
-    }
-
-    const isIdentifier = id.isIdentifier();
-    const isMemberExpression = id.isMemberExpression();
-
-    if (!isIdentifier && !isMemberExpression) {
-        throw generateError(id, {
-            errorInfo: DecoratorErrors.FUNCTION_IDENTIFIER_SHOULD_BE_FIRST_PARAMETER,
-        });
-    }
-
-    if (id.isMemberExpression({ computed: true })) {
-        throw generateError(id, {
-            errorInfo: DecoratorErrors.FUNCTION_IDENTIFIER_CANNOT_HAVE_COMPUTED_PROPS,
-        });
-    }
-
-    if (isMemberExpression && !id.get('object').isIdentifier()) {
-        throw generateError(id, {
-            errorInfo: DecoratorErrors.FUNCTION_IDENTIFIER_CANNOT_HAVE_NESTED_MEMBER_EXRESSIONS,
-        });
-    }
-
-    // Ensure wire adapter is imported (check for member expression or identifier)
-    const wireBinding = isMemberExpression ? id.node.object.name : id.node.name;
-    if (!path.scope.getBinding(wireBinding)) {
-        throw generateError(id, {
-            errorInfo: DecoratorErrors.WIRE_ADAPTER_SHOULD_BE_IMPORTED,
-            messageArgs: [id.node.name],
-        });
-    }
-
-    // ensure wire adapter is a first parameter
-    if (
-        wireBinding &&
-        !path.scope.getBinding(wireBinding).path.isImportSpecifier() &&
-        !path.scope.getBinding(wireBinding).path.isImportDefaultSpecifier()
-    ) {
-        throw generateError(id, {
-            errorInfo: DecoratorErrors.IMPORTED_FUNCTION_IDENTIFIER_SHOULD_BE_FIRST_PARAMETER,
-        });
-    }
-
-    if (config && !config.isObjectExpression()) {
-        throw generateError(config, {
-            errorInfo: DecoratorErrors.CONFIG_OBJECT_SHOULD_BE_SECOND_PARAMETER,
-        });
-    }
-}
-
-function validateUsageWithOtherDecorators(path, decorators) {
-    decorators.forEach((decorator) => {
-        if (
-            path !== decorator.path &&
-            decorator.name === WIRE_DECORATOR &&
-            decorator.path.parentPath.node === path.parentPath.node
-        ) {
-            throw generateError(path, {
-                errorInfo: DecoratorErrors.ONE_WIRE_DECORATOR_ALLOWED,
-            });
-        }
-        if (
-            (decorator.name === API_DECORATOR || decorator.name === TRACK_DECORATOR) &&
-            decorator.path.parentPath.node === path.parentPath.node
-        ) {
-            throw generateError(path, {
-                errorInfo: DecoratorErrors.CONFLICT_WITH_ANOTHER_DECORATOR,
-                messageArgs: [decorator.name],
-            });
-        }
-    });
-}
-
-module.exports = function validate(decorators) {
-    decorators.filter(isWireDecorator).forEach(({ path }) => {
-        validateUsageWithOtherDecorators(path, decorators);
-        validateWireParameters(path, decorators);
-    });
-};

package/src/dedupe-imports.js

@@ -1,56 +0,0 @@
-/*
- * Copyright (c) 2020, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-
-function defaultImport(t, specifiers) {
-    const defaultImport = specifiers.find((s) => t.isImportDefaultSpecifier(s));
-    return defaultImport && defaultImport.local.name;
-}
-
-module.exports = function ({ types: t }) {
-    return function (path) {
-        const body = path.get('body');
-        const importStatements = body.filter((s) => s.isImportDeclaration());
-        const visited = new Map();
-
-        importStatements.forEach((importPath) => {
-            const sourceLiteral = importPath.node.source;
-
-            // If the import is of the type import * as X, just ignore it since we can't dedupe
-            if (importPath.node.specifiers.some(t.isImportNamespaceSpecifier)) {
-                return;
-            }
-
-            // If we have seen the same source, we will try to dedupe it
-            if (visited.has(sourceLiteral.value)) {
-                const visitedImport = visited.get(sourceLiteral.value);
-                const visitedSpecifiers = visitedImport.node.specifiers;
-                const visitedDefaultImport = defaultImport(t, visitedSpecifiers);
-
-                // We merge all the named imports unless is a default with the same name
-                let canImportBeRemoved = true;
-                importPath.node.specifiers.forEach((s) => {
-                    if (visitedDefaultImport && t.isImportDefaultSpecifier(s)) {
-                        if (visitedDefaultImport !== s.local.name) {
-                            canImportBeRemoved = false;
-                        }
-                    } else {
-                        visitedSpecifiers.push(s);
-                    }
-                });
-
-                if (canImportBeRemoved) {
-                    importPath.remove();
-                }
-
-                // We need to sort the imports due to a bug in babel where default must be first
-                visitedSpecifiers.sort((a) => (t.isImportDefaultSpecifier(a) ? -1 : 1));
-            } else {
-                visited.set(sourceLiteral.value, importPath);
-            }
-        });
-    };
-};

package/src/dynamic-imports.js

@@ -1,70 +0,0 @@
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-const moduleImports = require('@babel/helper-module-imports');
-const { LWCClassErrors } = require('@lwc/errors');
-
-const { generateError } = require('./utils');
-
-function getImportSource(path) {
-    return path.parentPath.get('arguments.0');
-}
-
-function validateImport(sourcePath) {
-    if (!sourcePath.isStringLiteral()) {
-        throw generateError(sourcePath, {
-            errorInfo: LWCClassErrors.INVALID_DYNAMIC_IMPORT_SOURCE_STRICT,
-            messageArgs: [String(sourcePath)],
-        });
-    }
-}
-/*
- * Expected API for this plugin:
- * { dynamicImports: { loader: string, strictSpecifier: boolean } }
- */
-module.exports = function () {
-    function getLoaderRef(path, loaderName, state) {
-        if (!state.loaderRef) {
-            state.loaderRef = moduleImports.addNamed(path, 'load', loaderName);
-        }
-        return state.loaderRef;
-    }
-
-    function addDynamicImportDependency(dependency, state) {
-        if (!state.dynamicImports) {
-            state.dynamicImports = [];
-        }
-
-        if (!state.dynamicImports.includes(dependency)) {
-            state.dynamicImports.push(dependency);
-        }
-    }
-
-    return {
-        Import(path, state) {
-            const { dynamicImports } = state.opts;
-            if (!dynamicImports) {
-                return;
-            }
-
-            const { loader, strictSpecifier } = dynamicImports;
-            const sourcePath = getImportSource(path);
-
-            if (strictSpecifier) {
-                validateImport(sourcePath);
-            }
-
-            if (loader) {
-                const loaderId = getLoaderRef(path, loader, state);
-                path.replaceWith(loaderId);
-            }
-
-            if (sourcePath.isStringLiteral()) {
-                addDynamicImportDependency(sourcePath.node.value, state);
-            }
-        },
-    };
-};

package/src/index.d.ts

@@ -1,10 +0,0 @@
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-
-import type { PluginObj } from '@babel/core';
-
-export default function babelPluginComponent(): PluginObj;

package/src/index.js

@@ -1,77 +0,0 @@
-/*
- * Copyright (c) 2018, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-const component = require('./component');
-const {
-    decorators,
-    removeImportedDecoratorSpecifiers,
-    validateImportedLwcDecoratorUsage,
-} = require('./decorators');
-const dedupeImports = require('./dedupe-imports');
-const dynamicImports = require('./dynamic-imports');
-const scopeCssImports = require('./scope-css-imports');
-const compilerVersionNumber = require('./compiler-version-number');
-const { getEngineImportSpecifiers } = require('./utils');
-
-/**
- * The transform is done in 2 passes:
- *    - First, apply in a single AST traversal the decorators and the component transformation.
- *    - Then, in a second path transform class properties using the official babel plugin "babel-plugin-transform-class-properties".
- */
-module.exports = function LwcClassTransform(api) {
-    const { ExportDefaultDeclaration: transformCreateRegisterComponent } = component(api);
-    const { Class: transformDecorators } = decorators(api);
-    const { Import: transformDynamicImports } = dynamicImports(api);
-    const { ClassBody: addCompilerVersionNumber } = compilerVersionNumber(api);
-
-    return {
-        manipulateOptions(opts, parserOpts) {
-            parserOpts.plugins.push('classProperties', [
-                'decorators',
-                { decoratorsBeforeExport: true },
-            ]);
-        },
-
-        visitor: {
-            // The LWC babel plugin is incompatible with other plugins. To get around this, we run the LWC babel plugin
-            // first by running all its traversals from this Program visitor.
-            Program: {
-                enter(path) {
-                    const engineImportSpecifiers = getEngineImportSpecifiers(path);
-
-                    // Validate the usage of LWC decorators.
-                    validateImportedLwcDecoratorUsage(engineImportSpecifiers);
-
-                    // Add ?scoped=true to *.scoped.css imports
-                    scopeCssImports(api, path);
-                },
-                exit(path) {
-                    const engineImportSpecifiers = getEngineImportSpecifiers(path);
-                    removeImportedDecoratorSpecifiers(engineImportSpecifiers);
-
-                    // Will eventually be removed to eliminate unnecessary complexity. Rollup already does this for us.
-                    dedupeImports(api)(path);
-                },
-            },
-
-            Import(path, state) {
-                transformDynamicImports(path, state);
-            },
-
-            Class(path) {
-                transformDecorators(path);
-            },
-
-            ClassBody(path) {
-                addCompilerVersionNumber(path);
-            },
-
-            ExportDefaultDeclaration(path, state) {
-                transformCreateRegisterComponent(path, state);
-            },
-        },
-    };
-};

package/src/scope-css-imports.js

@@ -1,23 +0,0 @@
-/*
- * Copyright (c) 2020, salesforce.com, inc.
- * All rights reserved.
- * SPDX-License-Identifier: MIT
- * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
- */
-
-// Add ?scoped=true to any imports ending with .scoped.css. This signals that the stylesheet
-// should be treated as "scoped".
-module.exports = function ({ types: t }, path) {
-    const programPath = path.isProgram() ? path : path.findParent((node) => node.isProgram());
-
-    return programPath.get('body').forEach((node) => {
-        const source = node.get('source');
-        if (
-            node.isImportDeclaration() &&
-            source.type === 'StringLiteral' &&
-            source.node.value.endsWith('.scoped.css')
-        ) {
-            source.replaceWith(t.stringLiteral(source.node.value + '?scoped=true'));
-        }
-    });
-};