babel-types-lib-helper v1.0.0

babel-types-lib-helper

• forked from https://github.com/babel/babel/tree/main/packages/babel-types
• just expose more APIS

install

• npm install babel-types-lib-helper

usage

examples

constants/

.constants___.generated
.constants___._constants

utils/

.utils___._shallowEqual
.utils___.cleanJSXElementLiteralChild
.utils___.inherit

validators/

exports.validators___ = {
    buildMatchMemberExpression:_buildMatchMemberExpression.default,
    generated:_generated4,
    isBinding:_isBinding.default,
    isBlockScoped:_isBlockScoped.default,
    isImmutable:_isImmutable.default,
    is:_is.default,
    isLet:_isLet.default,
    isNode:_isNode.default,
    isNodesEquivalent:_isNodesEquivalent.default,
    isPlaceholderType:_isPlaceholderType.default,
    isReferenced:_isReferenced.default,
    isScope:_isScope.default,
    isSpecifierDefault:_isSpecifierDefault.default,
    isType:_isType.default,
    isValidES3Identifier:_isValidES3Identifier.default,
    isValidIdentifier:_isValidIdentifier.default,
    isVar:_isVar.default,
    matchesPattern,_matchesPattern.default,
    react: {
        isReactComponent:_isReactComponent.default,
        isCompatTag:_isCompatTag.default,
    },
    _validate,
}

traverse/

.traverse
.traverseFast
.traverse___.traverseSimpleImpl

retrievers/

.getBindingIdentifiers
.getOuterBindingIdentifiers

modifications/

exports.modifications___ = {
    appendToMemberExpression:_appendToMemberExpression.default,
    flow:{
        removeTypeDuplicates:_removeTypeDuplicates.default
    },
    inherits:_inherits.default,
    prependToMemberExpression:_prependToMemberExpression.default,
    removePropertiesDeep:_removePropertiesDeep.default,
    removeProperties:_removeProperties.default,
    typescript: {
        removeTypeDuplicates:
            require("./modifications/typescript/removeTypeDuplicates").default
    }
}

asserts/

exports.asserts___ = {
    generated:_generated,
    assertNode:_assertNode.default,
}

comments/

exports.comments___ = {
    addComment:_addComment.default,
    addComments:_addComments.default,
    inheritInnerComments:_inheritInnerComments.default,
    inheritLeadingComments:_inheritLeadingComments.default,
    inheritTrailingComments:_inheritTrailingComments.default,
    inheritsComments:_inheritsComments.default,
    removeComments:_removeComments.default,
}

builders/

exports.builders___ = {
    builder:require("./builders/builder.js").default,
    flow:{
        createFlowUnionType:_createFlowUnionType.default,
        createTypeAnnotationBasedOnTypeof:
            _createTypeAnnotationBasedOnTypeof.default
    },
    generated:{
        bcamel:_uppercase,
        lcamel:_generated2,
    },
    react:{
        buildChildren:require("./builders/react/buildChildren.js").default
    },
    typescript:{
        createTSUnionType:_createTSUnionType.default
    }
}

clone/

clone___:
    {
      cloneNode: {
        default: [Function: cloneNode],
        has: [Function: bound call],
        cloneIfNode: [Function: cloneIfNode],
        cloneIfNodeOrArray: [Function: cloneIfNodeOrArray],
        cloneNode: [Function: cloneNode],
        maybeCloneComments: [Function: maybeCloneComments]
      },
      clone: [Function: clone],
      cloneDeep: [Function: cloneDeep],
      cloneWithoutLoc: [Function: cloneWithoutLoc],
      cloneDeepWithoutLoc: [Function: cloneDeepWithoutLoc]
    }

converters/

.converters___
    {
      ensureBlock: [Function: ensureBlock],
      gatherSequenceExpressions: [Function: gatherSequenceExpressions],
      toBindingIdentifierName: [Function: toBindingIdentifierName],
      toBlock: [Function: toBlock],
      toComputedKey: [Function: toComputedKey],
      toExpression: [Function: toExpression],
      toIdentifier: [Function: toIdentifier],
      toKeyAlias: [Function: toKeyAlias] { uid: 0, increment: [Function (anonymous)] },
      toSequenceExpression: [Function: toSequenceExpression],
      toStatement: [Function: toStatement],
      valueToNode: {
        default: [Function: valueToNode],
        objectToString: [Function: bound call],
        isRegExp: [Function: isRegExp],
        isPlainObject: [Function: isPlainObject],
        valueToNode: [Function: valueToNode]
      }
    }

definitions/

definitions___
    {
        cfg___:require("./definitions/cfg___"),
        utils:require("./definitions/utils"),
        typescript: {
            cfg___:{
                l0:require("./definitions/typescript.cfg___"),
                l1:{}
            },
            l0:require("./definitions/typescript"),
            l1:{}
        },
        placeholders:require("./definitions/placeholders"),
        misc: {
            cfg___: {
                l0:{},
                l1:{}
            },
            l0:require("./definitions/misc"),
            l1:{}
        },
        jsx: {
            cfg___: {
                l0:{},
                l1:{}
            },
            l0:require("./definitions/jsx"),
            l1:{}
        },
        flow: {
            cfg___: {
                l0:{},
                l1:{}
            },
            l0:require("./definitions/flow"),
            l1:{}
        },
        experimental: {
            cfg___: {
                l0:{},
                l1:{}
            },
            l0:require("./definitions/experimental"),
            l1:{}
        },
        core: {
            cfg___: {
                l0:require("./definitions/core.cfg___"),
                l1:{}
            },
            l0:require("./definitions/core"),
            l1:{}
        }
    };
    ['core','experimental','flow','jsx','misc','typescript'].forEach(
        cate => {
            let tnames = definitions___[cate].l0.ALL_TYPE_NAMES___;
            let store = require("./definitions/utils").store___;
            let cfg = definitions___.cfg___;
            tnames.forEach(
                tname=> {
                    definitions___[cate].l1[tname] = store[tname];
                    definitions___[cate].cfg___.l1[tname] = cfg[tname];
                }
            )
        }
    );

LICENSE

• ISC