@lwc/babel-plugin-component 2.41.3 → 2.43.0

package/src/decorators/api/transform.js

@@ -1,95 +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 {
-    DECORATOR_TYPES,
-    LWC_COMPONENT_PROPERTIES: { PUBLIC_METHODS, PUBLIC_PROPS },
-} = require('../../constants');
-
-const { isApiDecorator } = require('./shared');
-
-const PUBLIC_PROP_BIT_MASK = {
-    PROPERTY: 0,
-    GETTER: 1,
-    SETTER: 2,
-};
-
-function getPropertyBitmask(type) {
-    switch (type) {
-        case DECORATOR_TYPES.GETTER:
-            return PUBLIC_PROP_BIT_MASK.GETTER;
-
-        case DECORATOR_TYPES.SETTER:
-            return PUBLIC_PROP_BIT_MASK.SETTER;
-
-        default:
-            return PUBLIC_PROP_BIT_MASK.PROPERTY;
-    }
-}
-
-function getSiblingGetSetPairType(propertyName, type, classBodyItems) {
-    const siblingKind = type === DECORATOR_TYPES.GETTER ? 'set' : 'get';
-    const siblingNode = classBodyItems.find((classBodyItem) => {
-        const isClassMethod = classBodyItem.isClassMethod({ kind: siblingKind });
-        const isSamePropertyName = classBodyItem.node.key.name === propertyName;
-        return isClassMethod && isSamePropertyName;
-    });
-    if (siblingNode) {
-        return siblingKind === 'get' ? DECORATOR_TYPES.GETTER : DECORATOR_TYPES.SETTER;
-    }
-}
-
-function computePublicPropsConfig(publicPropertyMetas, classBodyItems) {
-    return publicPropertyMetas.reduce((acc, { propertyName, decoratedNodeType }) => {
-        if (!(propertyName in acc)) {
-            acc[propertyName] = {};
-        }
-        acc[propertyName].config |= getPropertyBitmask(decoratedNodeType);
-
-        if (
-            decoratedNodeType === DECORATOR_TYPES.GETTER ||
-            decoratedNodeType === DECORATOR_TYPES.SETTER
-        ) {
-            // With the latest decorator spec, only one of the getter/setter pair needs a decorator.
-            // We need to add the proper bitmask for the sibling getter/setter if it exists.
-            const pairType = getSiblingGetSetPairType(
-                propertyName,
-                decoratedNodeType,
-                classBodyItems
-            );
-            if (pairType) {
-                acc[propertyName].config |= getPropertyBitmask(pairType);
-            }
-        }
-
-        return acc;
-    }, {});
-}
-
-module.exports = function transform(t, decoratorMetas, classBodyItems) {
-    const objectProperties = [];
-    const apiDecoratorMetas = decoratorMetas.filter(isApiDecorator);
-    const publicPropertyMetas = apiDecoratorMetas.filter(
-        ({ decoratedNodeType }) => decoratedNodeType !== DECORATOR_TYPES.METHOD
-    );
-    if (publicPropertyMetas.length) {
-        const propsConfig = computePublicPropsConfig(publicPropertyMetas, classBodyItems);
-        objectProperties.push(
-            t.objectProperty(t.identifier(PUBLIC_PROPS), t.valueToNode(propsConfig))
-        );
-    }
-
-    const publicMethodMetas = apiDecoratorMetas.filter(
-        ({ decoratedNodeType }) => decoratedNodeType === DECORATOR_TYPES.METHOD
-    );
-    if (publicMethodMetas.length) {
-        const methodNames = publicMethodMetas.map(({ propertyName }) => propertyName);
-        objectProperties.push(
-            t.objectProperty(t.identifier(PUBLIC_METHODS), t.valueToNode(methodNames))
-        );
-    }
-    return objectProperties;
-};

package/src/decorators/api/validate.js

@@ -1,160 +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 { generateError } = require('../../utils');
-const {
-    AMBIGUOUS_PROP_SET,
-    DISALLOWED_PROP_SET,
-    LWC_PACKAGE_EXPORTS: { TRACK_DECORATOR },
-    DECORATOR_TYPES,
-} = require('../../constants');
-
-const { isApiDecorator } = require('./shared');
-
-function validateConflict(path, decorators) {
-    const isPublicFieldTracked = decorators.some(
-        (decorator) =>
-            decorator.name === TRACK_DECORATOR &&
-            decorator.path.parentPath.node === path.parentPath.node
-    );
-
-    if (isPublicFieldTracked) {
-        throw generateError(path, {
-            errorInfo: DecoratorErrors.API_AND_TRACK_DECORATOR_CONFLICT,
-        });
-    }
-}
-
-function isBooleanPropDefaultTrue(property) {
-    const propertyValue = property.node.value;
-    return propertyValue && propertyValue.type === 'BooleanLiteral' && propertyValue.value;
-}
-
-function validatePropertyValue(property) {
-    if (isBooleanPropDefaultTrue(property)) {
-        throw generateError(property, {
-            errorInfo: DecoratorErrors.INVALID_BOOLEAN_PUBLIC_PROPERTY,
-        });
-    }
-}
-
-function validatePropertyName(property) {
-    if (property.node.computed) {
-        throw generateError(property, {
-            errorInfo: DecoratorErrors.PROPERTY_CANNOT_BE_COMPUTED,
-        });
-    }
-
-    const propertyName = property.get('key.name').node;
-
-    if (propertyName === 'part') {
-        throw generateError(property, {
-            errorInfo: DecoratorErrors.PROPERTY_NAME_PART_IS_RESERVED,
-            messageArgs: [propertyName],
-        });
-    } else if (propertyName.startsWith('on')) {
-        throw generateError(property, {
-            errorInfo: DecoratorErrors.PROPERTY_NAME_CANNOT_START_WITH_ON,
-            messageArgs: [propertyName],
-        });
-    } else if (propertyName.startsWith('data') && propertyName.length > 4) {
-        throw generateError(property, {
-            errorInfo: DecoratorErrors.PROPERTY_NAME_CANNOT_START_WITH_DATA,
-            messageArgs: [propertyName],
-        });
-    } else if (DISALLOWED_PROP_SET.has(propertyName)) {
-        throw generateError(property, {
-            errorInfo: DecoratorErrors.PROPERTY_NAME_IS_RESERVED,
-            messageArgs: [propertyName],
-        });
-    } else if (AMBIGUOUS_PROP_SET.has(propertyName)) {
-        const camelCased = AMBIGUOUS_PROP_SET.get(propertyName);
-        throw generateError(property, {
-            errorInfo: DecoratorErrors.PROPERTY_NAME_IS_AMBIGUOUS,
-            messageArgs: [propertyName, camelCased],
-        });
-    }
-}
-
-function validateSingleApiDecoratorOnSetterGetterPair(decorators) {
-    // keep track of visited class methods
-    const visitedMethods = new Set();
-
-    decorators.forEach((decorator) => {
-        const { path, decoratedNodeType } = decorator;
-
-        // since we are validating get/set we only look at @api methods
-        if (
-            isApiDecorator(decorator) &&
-            (decoratedNodeType === DECORATOR_TYPES.GETTER ||
-                decoratedNodeType === DECORATOR_TYPES.SETTER)
-        ) {
-            const methodPath = path.parentPath;
-            const methodName = methodPath.get('key.name').node;
-
-            if (visitedMethods.has(methodName)) {
-                throw generateError(methodPath, {
-                    errorInfo: DecoratorErrors.SINGLE_DECORATOR_ON_SETTER_GETTER_PAIR,
-                    messageArgs: [methodName],
-                });
-            }
-
-            visitedMethods.add(methodName);
-        }
-    });
-}
-
-function validateUniqueness(decorators) {
-    const apiDecorators = decorators.filter(isApiDecorator);
-    for (let i = 0; i < apiDecorators.length; i++) {
-        const { path: currentPath, type: currentType } = apiDecorators[i];
-        const currentPropertyName = currentPath.parentPath.get('key.name').node;
-
-        for (let j = 0; j < apiDecorators.length; j++) {
-            const { path: comparePath, type: compareType } = apiDecorators[j];
-            const comparePropertyName = comparePath.parentPath.get('key.name').node;
-
-            // We will throw if the considered properties have the same name, and when their
-            // are not part of a pair of getter/setter.
-            const haveSameName = currentPropertyName === comparePropertyName;
-            const isDifferentProperty = currentPath !== comparePath;
-            const isGetterSetterPair =
-                (currentType === DECORATOR_TYPES.GETTER &&
-                    compareType === DECORATOR_TYPES.SETTER) ||
-                (currentType === DECORATOR_TYPES.SETTER && compareType === DECORATOR_TYPES.GETTER);
-
-            if (haveSameName && isDifferentProperty && !isGetterSetterPair) {
-                throw generateError(comparePath, {
-                    errorInfo: DecoratorErrors.DUPLICATE_API_PROPERTY,
-                    messageArgs: [currentPropertyName],
-                });
-            }
-        }
-    }
-}
-
-module.exports = function validate(decorators) {
-    const apiDecorators = decorators.filter(isApiDecorator);
-    if (apiDecorators.length === 0) {
-        return;
-    }
-
-    apiDecorators.forEach(({ path, decoratedNodeType }) => {
-        validateConflict(path, decorators);
-
-        if (decoratedNodeType !== DECORATOR_TYPES.METHOD) {
-            const property = path.parentPath;
-
-            validatePropertyName(property);
-            validatePropertyValue(property);
-        }
-    });
-
-    validateSingleApiDecoratorOnSetterGetterPair(decorators);
-    validateUniqueness(decorators);
-};

package/src/decorators/index.js

@@ -1,271 +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 { DecoratorErrors } = require('@lwc/errors');
-
-const { DECORATOR_TYPES, LWC_PACKAGE_ALIAS, REGISTER_DECORATORS_ID } = require('../constants');
-const {
-    generateError,
-    isClassMethod,
-    isSetterClassMethod,
-    isGetterClassMethod,
-} = require('../utils');
-
-const api = require('./api');
-const wire = require('./wire');
-const track = require('./track');
-
-const DECORATOR_TRANSFORMS = [api, wire, track];
-const AVAILABLE_DECORATORS = DECORATOR_TRANSFORMS.map((transform) => transform.name).join(', ');
-
-function isLwcDecoratorName(name) {
-    return DECORATOR_TRANSFORMS.some((transform) => transform.name === name);
-}
-
-/** Returns a list of all the references to an identifier */
-function getReferences(identifier) {
-    return identifier.scope.getBinding(identifier.node.name).referencePaths;
-}
-
-/** Returns the type of decorator depdending on the property or method if get applied to */
-function getDecoratedNodeType(decoratorPath) {
-    const propertyOrMethod = decoratorPath.parentPath;
-    if (isClassMethod(propertyOrMethod)) {
-        return DECORATOR_TYPES.METHOD;
-    } else if (isGetterClassMethod(propertyOrMethod)) {
-        return DECORATOR_TYPES.GETTER;
-    } else if (isSetterClassMethod(propertyOrMethod)) {
-        return DECORATOR_TYPES.SETTER;
-    } else if (propertyOrMethod.isClassProperty()) {
-        return DECORATOR_TYPES.PROPERTY;
-    } else {
-        throw generateError(propertyOrMethod, {
-            errorInfo: DecoratorErrors.INVALID_DECORATOR_TYPE,
-        });
-    }
-}
-
-function validateImportedLwcDecoratorUsage(engineImportSpecifiers) {
-    engineImportSpecifiers
-        .filter(({ name }) => isLwcDecoratorName(name))
-        .reduce((acc, { name, path }) => {
-            // Get a list of all the  local references
-            const local = path.get('imported');
-            const references = getReferences(local).map((reference) => ({
-                name,
-                reference,
-            }));
-
-            return [...acc, ...references];
-        }, [])
-        .forEach(({ name, reference }) => {
-            // Get the decorator from the identifier
-            // If the the decorator is:
-            //   - an identifier @track : the decorator is the parent of the identifier
-            //   - a call expression @wire("foo") : the decorator is the grand-parent of the identifier
-            const decorator = reference.parentPath.isDecorator()
-                ? reference.parentPath
-                : reference.parentPath.parentPath;
-
-            if (!decorator.isDecorator()) {
-                throw generateError(decorator, {
-                    errorInfo: DecoratorErrors.IS_NOT_DECORATOR,
-                    messageArgs: [name],
-                });
-            }
-
-            const propertyOrMethod = decorator.parentPath;
-            if (!propertyOrMethod.isClassProperty() && !propertyOrMethod.isClassMethod()) {
-                throw generateError(propertyOrMethod, {
-                    errorInfo: DecoratorErrors.IS_NOT_CLASS_PROPERTY_OR_CLASS_METHOD,
-                    messageArgs: [name],
-                });
-            }
-        });
-}
-
-function isImportedFromLwcSource(decoratorBinding) {
-    const bindingPath = decoratorBinding.path;
-    return bindingPath.isImportSpecifier() && bindingPath.parent.source.value === 'lwc';
-}
-
-/** Validate the usage of decorator by calling each validation function */
-function validate(decorators) {
-    for (const { name, path } of decorators) {
-        const binding = path.scope.getBinding(name);
-        if (binding === undefined || !isImportedFromLwcSource(binding)) {
-            throw generateInvalidDecoratorError(path);
-        }
-    }
-    DECORATOR_TRANSFORMS.forEach(({ validate }) => validate(decorators));
-}
-
-/** Remove import specifiers. It also removes the import statement if the specifier list becomes empty */
-function removeImportedDecoratorSpecifiers(engineImportSpecifiers) {
-    engineImportSpecifiers
-        .filter(({ name }) => isLwcDecoratorName(name))
-        .forEach(({ path }) => {
-            const importStatement = path.parentPath;
-            path.remove();
-            if (importStatement.get('specifiers').length === 0) {
-                importStatement.remove();
-            }
-        });
-}
-
-function generateInvalidDecoratorError(path) {
-    const expressionPath = path.get('expression');
-    const { node } = path;
-    const { expression } = node;
-
-    let name;
-    if (expressionPath.isIdentifier()) {
-        name = expression.name;
-    } else if (expressionPath.isCallExpression()) {
-        name = expression.callee.name;
-    }
-
-    if (name) {
-        return generateError(path.parentPath, {
-            errorInfo: DecoratorErrors.INVALID_DECORATOR_WITH_NAME,
-            messageArgs: [name, AVAILABLE_DECORATORS, LWC_PACKAGE_ALIAS],
-        });
-    } else {
-        return generateError(path.parentPath, {
-            errorInfo: DecoratorErrors.INVALID_DECORATOR,
-            messageArgs: [AVAILABLE_DECORATORS, LWC_PACKAGE_ALIAS],
-        });
-    }
-}
-
-function collectDecoratorPaths(bodyItems) {
-    return bodyItems.reduce((acc, bodyItem) => {
-        const decorators = bodyItem.get('decorators');
-        if (decorators && decorators.length) {
-            acc.push(...decorators);
-        }
-        return acc;
-    }, []);
-}
-
-function getDecoratorMetadata(decoratorPath) {
-    const expressionPath = decoratorPath.get('expression');
-
-    let name;
-    if (expressionPath.isIdentifier()) {
-        name = expressionPath.node.name;
-    } else if (expressionPath.isCallExpression()) {
-        name = expressionPath.node.callee.name;
-    } else {
-        throw generateInvalidDecoratorError(decoratorPath);
-    }
-
-    const propertyName = decoratorPath.parent.key.name;
-    const decoratedNodeType = getDecoratedNodeType(decoratorPath);
-
-    return {
-        name,
-        propertyName,
-        path: decoratorPath,
-        decoratedNodeType,
-    };
-}
-
-function getMetadataObjectPropertyList(t, decoratorMetas, classBodyItems) {
-    const list = [
-        ...api.transform(t, decoratorMetas, classBodyItems),
-        ...track.transform(t, decoratorMetas),
-        ...wire.transform(t, decoratorMetas),
-    ];
-
-    const fieldNames = classBodyItems
-        .filter((field) => field.isClassProperty({ computed: false, static: false }))
-        .filter((field) => !field.node.decorators)
-        .map((field) => field.node.key.name);
-    if (fieldNames.length) {
-        list.push(t.objectProperty(t.identifier('fields'), t.valueToNode(fieldNames)));
-    }
-
-    return list;
-}
-
-function decorators({ types: t }) {
-    function createRegisterDecoratorsCallExpression(path, classExpression, props) {
-        const id = moduleImports.addNamed(path, REGISTER_DECORATORS_ID, LWC_PACKAGE_ALIAS);
-        return t.callExpression(id, [classExpression, t.objectExpression(props)]);
-    }
-
-    // Babel reinvokes visitors for node reinsertion so we use this to avoid an infinite loop.
-    const visitedClasses = new WeakSet();
-
-    return {
-        Class(path) {
-            const { node } = path;
-
-            if (visitedClasses.has(node)) {
-                return;
-            }
-            visitedClasses.add(node);
-
-            const classBodyItems = path.get('body.body');
-            if (classBodyItems.length === 0) {
-                return;
-            }
-
-            const decoratorPaths = collectDecoratorPaths(classBodyItems);
-            const decoratorMetas = decoratorPaths.map(getDecoratorMetadata);
-
-            validate(decoratorMetas);
-
-            const metaPropertyList = getMetadataObjectPropertyList(
-                t,
-                decoratorMetas,
-                classBodyItems
-            );
-            if (metaPropertyList.length === 0) {
-                return;
-            }
-
-            decoratorPaths.forEach((path) => path.remove());
-
-            const isAnonymousClassDeclaration =
-                path.isClassDeclaration() && !path.get('id').isIdentifier();
-            const shouldTransformAsClassExpression =
-                path.isClassExpression() || isAnonymousClassDeclaration;
-
-            if (shouldTransformAsClassExpression) {
-                // Example:
-                //      export default class extends LightningElement {}
-                // Output:
-                //      export default registerDecorators(class extends LightningElement {});
-                // if it does not have an id, we can treat it as a ClassExpression
-                const classExpression = t.toExpression(node);
-                path.replaceWith(
-                    createRegisterDecoratorsCallExpression(path, classExpression, metaPropertyList)
-                );
-            } else {
-                // Example: export default class NamedClass extends LightningElement {}
-                // Output:
-                //      export default class NamedClass extends LightningElement {}
-                //      registerDecorators(NamedClass);
-                // Note: This will be further transformed
-                const statementPath = path.getStatementParent();
-                statementPath.insertAfter(
-                    t.expressionStatement(
-                        createRegisterDecoratorsCallExpression(path, node.id, metaPropertyList)
-                    )
-                );
-            }
-        },
-    };
-}
-
-module.exports = {
-    decorators,
-    removeImportedDecoratorSpecifiers,
-    validateImportedLwcDecoratorUsage,
-};

package/src/decorators/track/index.js

@@ -1,49 +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_COMPONENT_PROPERTIES,
-    LWC_PACKAGE_EXPORTS: { TRACK_DECORATOR },
-} = require('../../constants');
-const { generateError } = require('../../utils');
-
-const TRACK_PROPERTY_VALUE = 1;
-
-function isTrackDecorator(decorator) {
-    return decorator.name === TRACK_DECORATOR;
-}
-
-function validate(decorators) {
-    decorators.filter(isTrackDecorator).forEach(({ path }) => {
-        if (!path.parentPath.isClassProperty()) {
-            throw generateError(path, {
-                errorInfo: DecoratorErrors.TRACK_ONLY_ALLOWED_ON_CLASS_PROPERTIES,
-            });
-        }
-    });
-}
-
-function transform(t, decoratorMetas) {
-    const objectProperties = [];
-    const trackDecoratorMetas = decoratorMetas.filter(isTrackDecorator);
-    if (trackDecoratorMetas.length) {
-        const config = trackDecoratorMetas.reduce((acc, meta) => {
-            acc[meta.propertyName] = TRACK_PROPERTY_VALUE;
-            return acc;
-        }, {});
-        objectProperties.push(
-            t.objectProperty(t.identifier(LWC_COMPONENT_PROPERTIES.TRACK), t.valueToNode(config))
-        );
-    }
-    return objectProperties;
-}
-
-module.exports = {
-    name: TRACK_DECORATOR,
-    transform,
-    validate,
-};

package/src/decorators/wire/index.js

@@ -1,18 +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_PACKAGE_EXPORTS: { WIRE_DECORATOR },
-} = require('../../constants');
-
-const validate = require('./validate');
-const transform = require('./transform');
-
-module.exports = {
-    name: WIRE_DECORATOR,
-    validate,
-    transform,
-};

package/src/decorators/wire/shared.js

@@ -1,17 +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_PACKAGE_EXPORTS: { WIRE_DECORATOR },
-} = require('../../constants');
-
-function isWireDecorator(decorator) {
-    return decorator.name === WIRE_DECORATOR;
-}
-
-module.exports = {
-    isWireDecorator,
-};