@dcloudio/uni-mp-compiler 0.0.1-nvue3.3030820220125001

package/dist/options.d.ts

@@ -0,0 +1,88 @@
+import { ParserPlugin } from '@babel/parser';
+import { GeneratorOptions } from '@babel/generator';
+import { CallExpression, Expression, ObjectExpression, ObjectProperty, SpreadElement } from '@babel/types';
+import { NodeTransform as VueNodeTransform, DirectiveTransform as VueDirectiveTransform } from '@vue/compiler-core';
+import { MiniProgramCompilerOptions } from '@dcloudio/uni-cli-shared';
+import { BindingMetadata, CompilerError, RootNode } from '@vue/compiler-core';
+import IdentifierGenerator from './identifier';
+import { TransformContext } from './transform';
+import { VForOptions } from './transforms/vFor';
+export interface CodegenRootNode extends RootNode {
+    renderData: ObjectExpression | CallExpression;
+    bindingComponents: TransformContext['bindingComponents'];
+}
+export interface ErrorHandlingOptions {
+    onWarn?: (warning: CompilerError) => void;
+    onError?: (error: CompilerError) => void;
+}
+interface ParserOptions {
+    /**
+     * e.g. platform native elements, e.g. `<div>` for browsers
+     */
+    isNativeTag?: (tag: string) => boolean;
+    /**
+     * e.g. native elements that can self-close, e.g. `<img>`, `<br>`, `<hr>`
+     */
+    isVoidTag?: (tag: string) => boolean;
+    /**
+     * Separate option for end users to extend the native elements list
+     */
+    isCustomElement?: (tag: string) => boolean | void;
+}
+interface SharedTransformCodegenOptions {
+    inline?: boolean;
+    isTS?: boolean;
+    root?: string;
+    filename?: string;
+    bindingMetadata?: BindingMetadata;
+    prefixIdentifiers?: boolean;
+    miniProgram?: MiniProgramCompilerOptions;
+}
+export interface TransformOptions extends SharedTransformCodegenOptions, ErrorHandlingOptions {
+    hashId?: string | null;
+    scopeId?: string | null;
+    filters?: string[];
+    renderDataSpread?: boolean;
+    cacheHandlers?: boolean;
+    nodeTransforms?: VueNodeTransform[];
+    directiveTransforms?: Record<string, VueDirectiveTransform | undefined>;
+    isBuiltInComponent?: (tag: string) => symbol | void;
+    isCustomElement?: (tag: string) => boolean | void;
+    expressionPlugins?: ParserPlugin[];
+    skipTransformIdentifier?: boolean;
+    bindingCssVars?: string[];
+}
+export interface CodegenRootScope {
+    id: IdentifierGenerator;
+    identifiers: string[];
+    properties: (ObjectProperty | SpreadElement)[];
+    parent: CodegenScope | null;
+}
+export interface CodegenVIfScopeInit {
+    name: 'if' | 'else-if' | 'else' | string;
+    condition?: Expression;
+}
+export declare type CodegenVForScopeInit = VForOptions & {
+    locals: string[];
+};
+export interface CodegenVIfScope extends CodegenRootScope, CodegenVIfScopeInit {
+    parentScope: CodegenRootScope | CodegenVForScope;
+}
+export interface CodegenVForScope extends CodegenRootScope, CodegenVForScopeInit {
+}
+export declare type CodegenScope = CodegenRootScope | CodegenVIfScope | CodegenVForScope;
+export interface CodegenOptions extends SharedTransformCodegenOptions {
+    mode?: 'module' | 'function';
+    scopeId?: string | null;
+    sourceMap?: boolean;
+    runtimeModuleName?: string;
+    runtimeGlobalName?: string;
+    generatorOpts?: GeneratorOptions;
+}
+export interface TemplateCodegenOptions extends Omit<MiniProgramCompilerOptions, 'filter'> {
+    scopeId?: string | null;
+    filename: string;
+    isBuiltInComponent: Required<TransformOptions>['isBuiltInComponent'];
+}
+export declare type CompilerOptions = ParserOptions & TransformOptions & CodegenOptions;
+export {};

package/dist/options.js

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

package/dist/parserOptions.d.ts

@@ -0,0 +1,7 @@
+import { ParserOptions } from '@vue/compiler-core';
+export declare const enum DOMNamespaces {
+    HTML = 0,
+    SVG = 1,
+    MATH_ML = 2
+}
+export declare const parserOptions: ParserOptions;

package/dist/parserOptions.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parserOptions = void 0;
+const shared_1 = require("@vue/shared");
+const decodeHtml_1 = require("./decodeHtml");
+const isRawTextContainer = /*#__PURE__*/ (0, shared_1.makeMap)('style,iframe,script,noscript', true);
+exports.parserOptions = {
+    isVoidTag: shared_1.isVoidTag,
+    isNativeTag: (tag) => (0, shared_1.isHTMLTag)(tag) || (0, shared_1.isSVGTag)(tag),
+    isPreTag: (tag) => tag === 'pre',
+    decodeEntities: decodeHtml_1.decodeHtml,
+    // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
+    getNamespace(tag, parent) {
+        let ns = parent ? parent.ns : 0 /* HTML */;
+        if (parent && ns === 2 /* MATH_ML */) {
+            if (parent.tag === 'annotation-xml') {
+                if (tag === 'svg') {
+                    return 1 /* SVG */;
+                }
+                if (parent.props.some((a) => a.type === 6 /* ATTRIBUTE */ &&
+                    a.name === 'encoding' &&
+                    a.value != null &&
+                    (a.value.content === 'text/html' ||
+                        a.value.content === 'application/xhtml+xml'))) {
+                    ns = 0 /* HTML */;
+                }
+            }
+            else if (/^m(?:[ions]|text)$/.test(parent.tag) &&
+                tag !== 'mglyph' &&
+                tag !== 'malignmark') {
+                ns = 0 /* HTML */;
+            }
+        }
+        else if (parent && ns === 1 /* SVG */) {
+            if (parent.tag === 'foreignObject' ||
+                parent.tag === 'desc' ||
+                parent.tag === 'title') {
+                ns = 0 /* HTML */;
+            }
+        }
+        if (ns === 0 /* HTML */) {
+            if (tag === 'svg') {
+                return 1 /* SVG */;
+            }
+            if (tag === 'math') {
+                return 2 /* MATH_ML */;
+            }
+        }
+        return ns;
+    },
+    // https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments
+    getTextMode({ tag, ns }) {
+        if (ns === 0 /* HTML */) {
+            if (tag === 'textarea' || tag === 'title') {
+                return 1 /* RCDATA */;
+            }
+            if (isRawTextContainer(tag)) {
+                return 2 /* RAWTEXT */;
+            }
+        }
+        return 0 /* DATA */;
+    },
+};

package/dist/runtimeHelpers.d.ts

@@ -0,0 +1,13 @@
+export declare const V_ON: unique symbol;
+export declare const V_FOR: unique symbol;
+export declare const EXTEND: unique symbol;
+export declare const SET_REF: unique symbol;
+export declare const CAMELIZE: unique symbol;
+export declare const HYPHENATE: unique symbol;
+export declare const RENDER_PROPS: unique symbol;
+export declare const RENDER_SLOT: unique symbol;
+export declare const DYNAMIC_SLOT: unique symbol;
+export declare const WITH_SCOPED_SLOT: unique symbol;
+export declare const STRINGIFY_STYLE: unique symbol;
+export declare const NORMALIZE_CLASS: unique symbol;
+export declare const TO_DISPLAY_STRING: unique symbol;

package/dist/runtimeHelpers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TO_DISPLAY_STRING = exports.NORMALIZE_CLASS = exports.STRINGIFY_STYLE = exports.WITH_SCOPED_SLOT = exports.DYNAMIC_SLOT = exports.RENDER_SLOT = exports.RENDER_PROPS = exports.HYPHENATE = exports.CAMELIZE = exports.SET_REF = exports.EXTEND = exports.V_FOR = exports.V_ON = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+exports.V_ON = Symbol(`vOn`);
+exports.V_FOR = Symbol(`vFor`);
+exports.EXTEND = Symbol(`extend`);
+exports.SET_REF = Symbol(`setRef`);
+exports.CAMELIZE = Symbol(`camelize`);
+exports.HYPHENATE = Symbol(`hyphenate`);
+exports.RENDER_PROPS = Symbol(`renderProps`);
+exports.RENDER_SLOT = Symbol(`renderSlot`);
+exports.DYNAMIC_SLOT = Symbol(`dynamicSlot`);
+exports.WITH_SCOPED_SLOT = Symbol(`withScopedSlot`);
+exports.STRINGIFY_STYLE = Symbol(`stringifyStyle`);
+exports.NORMALIZE_CLASS = Symbol(`normalizeClass`);
+exports.TO_DISPLAY_STRING = Symbol(`toDisplayString`);
+(0, compiler_core_1.registerRuntimeHelpers)({
+    [exports.V_ON]: 'o',
+    [exports.V_FOR]: 'f',
+    [exports.EXTEND]: 'e',
+    [exports.SET_REF]: 'sr',
+    [exports.CAMELIZE]: 'c',
+    [exports.HYPHENATE]: 'h',
+    [exports.RENDER_PROPS]: 'p',
+    [exports.RENDER_SLOT]: 'r',
+    [exports.DYNAMIC_SLOT]: 'd',
+    [exports.WITH_SCOPED_SLOT]: 'w',
+    [exports.STRINGIFY_STYLE]: 's',
+    [exports.NORMALIZE_CLASS]: 'n',
+    [exports.TO_DISPLAY_STRING]: `t`,
+});

package/dist/template/codegen.d.ts

@@ -0,0 +1,19 @@
+import { MiniProgramCompilerOptions } from '@dcloudio/uni-cli-shared';
+import { ElementNode, RootNode, TemplateChildNode } from '@vue/compiler-core';
+import { TemplateCodegenOptions } from '../options';
+import { TransformContext } from '../transform';
+interface TemplateCodegenContext {
+    code: string;
+    directive: string;
+    scopeId?: string | null;
+    event: MiniProgramCompilerOptions['event'];
+    slot: MiniProgramCompilerOptions['slot'];
+    lazyElement: MiniProgramCompilerOptions['lazyElement'];
+    component: MiniProgramCompilerOptions['component'];
+    isBuiltInComponent: TransformContext['isBuiltInComponent'];
+    push(code: string): void;
+}
+export declare function generate({ children }: RootNode, { slot, event, scopeId, emitFile, filename, directive, lazyElement, isBuiltInComponent, component, }: TemplateCodegenOptions): void;
+export declare function genNode(node: TemplateChildNode, context: TemplateCodegenContext): void;
+export declare function genElementProps(node: ElementNode, context: TemplateCodegenContext): void;
+export {};

package/dist/template/codegen.js

@@ -0,0 +1,381 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genElementProps = exports.genNode = exports.generate = void 0;
+const shared_1 = require("@vue/shared");
+const uni_shared_1 = require("@dcloudio/uni-shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const codegen_1 = require("../codegen");
+const vFor_1 = require("../transforms/vFor");
+const vIf_1 = require("../transforms/vIf");
+const vSlot_1 = require("../transforms/vSlot");
+const utils_1 = require("../transforms/utils");
+function generate({ children }, { slot, event, scopeId, emitFile, filename, directive, lazyElement, isBuiltInComponent, component, }) {
+    const context = {
+        slot,
+        event,
+        code: '',
+        scopeId,
+        directive,
+        lazyElement,
+        component,
+        isBuiltInComponent,
+        push(code) {
+            context.code += code;
+        },
+    };
+    children.forEach((node) => {
+        genNode(node, context);
+    });
+    emitFile({ type: 'asset', fileName: filename, source: context.code });
+}
+exports.generate = generate;
+function genNode(node, context) {
+    switch (node.type) {
+        case 9 /* IF */:
+            return node.branches.forEach((node) => {
+                genNode(node, context);
+            });
+        case 2 /* TEXT */:
+            return genText(node, context);
+        case 5 /* INTERPOLATION */:
+            return genExpression(node.content, context);
+        case 1 /* ELEMENT */:
+            if (node.tagType === 2 /* SLOT */) {
+                return genSlot(node, context);
+            }
+            else if (node.tagType === 1 /* COMPONENT */) {
+                return genComponent(node, context);
+            }
+            else if (node.tagType === 3 /* TEMPLATE */) {
+                return genTemplate(node, context);
+            }
+            else if (isLazyElement(node, context)) {
+                return genLazyElement(node, context);
+            }
+            return genElement(node, context);
+    }
+}
+exports.genNode = genNode;
+function genText(node, { push }) {
+    push(node.content);
+}
+function genExpression(node, { push }) {
+    push(`{{${(0, codegen_1.genExpr)(node)}}}`);
+}
+function genVIf(exp, { push, directive }) {
+    push(` ${directive}if="{{${exp}}}"`);
+}
+function genVElseIf(exp, { push, directive }) {
+    push(` ${directive}elif="{{${exp}}}"`);
+}
+function genVElse({ push, directive }) {
+    push(` ${directive}else`);
+}
+function genVFor(node, { push, directive }) {
+    const { sourceCode, valueAlias, indexAlias } = node.vFor;
+    push(` ${directive}for="${sourceCode}"`);
+    if (valueAlias) {
+        push(` ${directive}for-item="${valueAlias}"`);
+    }
+    if (valueAlias === 'index') {
+        push(` ${directive}for-index="${indexAlias}"`);
+    }
+    const keyProp = (0, compiler_core_1.findProp)(node, 'key', true);
+    if (keyProp) {
+        const key = keyProp.exp.content;
+        push(` ${directive}key="${key.includes('.') ? key.split('.')[1] : key}"`);
+        node.props.splice(node.props.indexOf(keyProp), 1);
+    }
+}
+function genSlot(node, context) {
+    var _a;
+    // 移除掉所有非name属性，即移除作用域插槽的绑定指令
+    node.props = node.props.filter((prop) => {
+        var _a;
+        if (prop.type === 6 /* ATTRIBUTE */) {
+            return prop.name === 'name';
+        }
+        else if (((_a = prop.arg) === null || _a === void 0 ? void 0 : _a.type) === 4 /* SIMPLE_EXPRESSION */) {
+            return prop.arg.content === 'name';
+        }
+    });
+    if (!node.children.length || context.slot.fallbackContent) {
+        // 无后备内容或支持后备内容
+        return genElement(node, context);
+    }
+    const { push } = context;
+    const isVIfSlot = (0, vIf_1.isIfElementNode)(node);
+    if (isVIfSlot) {
+        push(`<block`);
+        genVIfCode(node, context);
+        push(`>`);
+        delete node.vIf;
+    }
+    const children = node.children.slice();
+    node.children.length = 0;
+    push(`<block`);
+    const nameProp = (0, compiler_core_1.findProp)(node, 'name');
+    genVIf(`$slots.` +
+        ((nameProp === null || nameProp === void 0 ? void 0 : nameProp.type) === 6 /* ATTRIBUTE */ && ((_a = nameProp.value) === null || _a === void 0 ? void 0 : _a.content)
+            ? nameProp.value.content
+            : uni_shared_1.SLOT_DEFAULT_NAME), context);
+    push(`>`);
+    genElement(node, context);
+    push(`</block>`);
+    push(`<block`);
+    genVElse(context);
+    push(`>`);
+    children.forEach((node) => {
+        genNode(node, context);
+    });
+    push(`</block>`);
+    if (isVIfSlot) {
+        push(`</block>`);
+    }
+}
+function genTemplate(node, context) {
+    const slotProp = node.props.find((prop) => {
+        var _a;
+        return prop.type === 7 /* DIRECTIVE */ &&
+            (prop.name === 'slot' ||
+                (prop.name === 'bind' &&
+                    ((_a = prop.arg) === null || _a === void 0 ? void 0 : _a.type) === 4 /* SIMPLE_EXPRESSION */ &&
+                    prop.arg.content === 'slot'));
+    });
+    // 为 bind 时，通常是作用域插槽生成的 vSlot.ts:197 createBindDirectiveNode('slot',...)
+    if (slotProp && (slotProp.name === 'bind' || (0, vSlot_1.findSlotName)(slotProp))) {
+        /**
+         * 仅百度、字节支持使用 block 作为命名插槽根节点
+         * 此处为了统一仅默认替换为view
+         * <template v-slot/> => <view slot="">
+         */
+        node.tag = 'view';
+    }
+    else {
+        // <template/> => <block/>
+        node.tag = 'block';
+    }
+    // @ts-ignore
+    node.tagType = 0 /* ELEMENT */;
+    // 仅单个子节点的命名插槽(非作用域)，直接使用子节点作为插槽使用，避免多增加的 view 节点影响 flex 排版
+    if (slotProp &&
+        node.tag === 'view' &&
+        !(0, vFor_1.isForElementNode)(node) &&
+        node.children.length === 1) {
+        const child = node.children[0];
+        if ((0, uni_cli_shared_1.isElementNode)(child) &&
+            !(0, vFor_1.isForElementNode)(child) &&
+            !(0, compiler_core_1.isSlotOutlet)(child)) {
+            child.props.push(slotProp);
+            return genElement(child, context);
+        }
+    }
+    return genElement(node, context);
+}
+function genComponent(node, context) {
+    var _a;
+    if ((_a = context.component) === null || _a === void 0 ? void 0 : _a.getPropertySync) {
+        return genElement(node, context);
+    }
+    if ((0, vIf_1.isIfElementNode)(node) || (0, vFor_1.isForElementNode)(node)) {
+        return genElement(node, context);
+    }
+    const prop = (0, compiler_core_1.findProp)(node, utils_1.ATTR_VUE_PROPS);
+    if (!prop) {
+        return genElement(node, context);
+    }
+    ;
+    node.vIf = {
+        name: 'if',
+        condition: prop.exp.content,
+    };
+    return genElement(node, context);
+}
+function isLazyElement(node, context) {
+    if (!context.lazyElement) {
+        return false;
+    }
+    const lazyProps = context.lazyElement[node.tag];
+    if (!lazyProps) {
+        return;
+    }
+    return node.props.some((prop) => prop.type === 7 /* DIRECTIVE */ &&
+        lazyProps.find((lazyProp) => {
+            var _a;
+            return (prop.name === lazyProp.name &&
+                ((_a = prop.arg) === null || _a === void 0 ? void 0 : _a.type) === 4 /* SIMPLE_EXPRESSION */ &&
+                lazyProp.arg.includes(prop.arg.content));
+        }));
+}
+/**
+ * 部分内置组件的部分事件在初始化时会立刻触发，但标准事件需要等首次渲染才能确认事件函数，故增加wx:if="{{r0}}"
+ * @param node
+ * @param context
+ */
+function genLazyElement(node, context) {
+    const { push } = context;
+    if (!(0, vIf_1.isIfElementNode)(node)) {
+        push(`<block`);
+        // r0 => ready 首次渲染
+        genVIf(`r0`, context);
+        push(`>`);
+        genElement(node, context);
+        push(`</block>`);
+        return;
+    }
+    // v-if,v-else-if 无需处理
+    if (node.vIf.name !== 'else') {
+        return genElement(node, context);
+    }
+    push(`<block`);
+    genVElse(context);
+    push(`>`);
+    node.vIf.name = 'if';
+    node.vIf.condition = 'r0';
+    genElement(node, context);
+    push(`</block>`);
+}
+function genVIfCode(node, context) {
+    const { name, condition } = node.vIf;
+    if (name === 'if') {
+        genVIf(condition, context);
+    }
+    else if (name === 'else-if') {
+        genVElseIf(condition, context);
+    }
+    else if (name === 'else') {
+        genVElse(context);
+    }
+}
+function genElement(node, context) {
+    const { children, isSelfClosing, props } = node;
+    let tag = node.tag;
+    // <template slot="left"/> => <block slot="left"/>
+    if (tag === 'template') {
+        if ((0, compiler_core_1.findProp)(node, 'slot')) {
+            tag = 'view';
+        }
+        else {
+            tag = 'block';
+        }
+    }
+    // 无用的 block
+    if (tag === 'block' &&
+        props.length === 0 &&
+        !(0, vIf_1.isIfElementNode)(node) &&
+        !(0, vFor_1.isForElementNode)(node)) {
+        return children.forEach((node) => {
+            genNode(node, context);
+        });
+    }
+    if ((0, uni_cli_shared_1.isUserComponent)(node, context)) {
+        tag = (0, shared_1.hyphenate)(tag);
+    }
+    const { push } = context;
+    const hasVIf = (0, vIf_1.isIfElementNode)(node);
+    const hasVFor = (0, vFor_1.isForElementNode)(node);
+    const hasVIfAndVFor = hasVIf && hasVFor;
+    // 小程序中 wx:else wx:elif 不支持与 wx:for 同时使用
+    // 故 if 需要补充一层 block
+    if (hasVIfAndVFor) {
+        push(`<block`);
+        genVIfCode(node, context);
+        push(`>`);
+    }
+    push(`<${tag}`);
+    if (!hasVIfAndVFor && hasVIf) {
+        genVIfCode(node, context);
+    }
+    if (hasVFor) {
+        genVFor(node, context);
+    }
+    if (props.length) {
+        genElementProps(node, context);
+    }
+    if (isSelfClosing) {
+        push(`/>`);
+    }
+    else {
+        push(`>`);
+        children.forEach((node) => {
+            genNode(node, context);
+        });
+        push(`</${tag}>`);
+    }
+    if (hasVIfAndVFor) {
+        push(`</block>`);
+    }
+}
+function genElementProps(node, context) {
+    node.props.forEach((prop) => {
+        if (prop.type === 6 /* ATTRIBUTE */) {
+            const { value } = prop;
+            if (value) {
+                context.push(` ${prop.name}="${value.content}"`);
+            }
+            else {
+                context.push(` ${prop.name}`);
+            }
+        }
+        else {
+            const { name } = prop;
+            if (name === 'on') {
+                genOn(prop, node, context);
+            }
+            else {
+                genDirectiveNode(prop, node, context);
+            }
+        }
+    });
+}
+exports.genElementProps = genElementProps;
+function genOn(prop, node, { push, event, isBuiltInComponent }) {
+    const arg = prop.arg.content;
+    const exp = prop.exp;
+    const modifiers = prop.modifiers;
+    const name = ((event === null || event === void 0 ? void 0 : event.format) || uni_cli_shared_1.formatMiniProgramEvent)(arg, {
+        isCatch: modifiers.includes('stop') || modifiers.includes('prevent'),
+        isCapture: modifiers.includes('capture'),
+        isComponent: (0, uni_cli_shared_1.isUserComponent)(node, { isBuiltInComponent }),
+    });
+    if (exp.isStatic) {
+        push(` ${name}="${exp.content}"`);
+    }
+    else {
+        push(` ${name}="{{${exp.content}}}"`);
+    }
+}
+function genDirectiveNode(prop, node, context) {
+    const { push, component } = context;
+    if (prop.name === 'slot') {
+        if (prop.arg) {
+            const arg = prop.arg;
+            if (arg.isStatic) {
+                const slotName = (0, uni_shared_1.dynamicSlotName)(arg.content);
+                // 非作用域默认插槽不生成 slot 属性
+                if (slotName !== uni_shared_1.SLOT_DEFAULT_NAME) {
+                    push(` slot="${slotName}"`);
+                }
+            }
+            else {
+                push(` slot="{{${arg.content}}}"`);
+            }
+        }
+    }
+    else if (prop.name === 'show') {
+        let hiddenPropName = 'hidden';
+        if ((0, uni_cli_shared_1.isUserComponent)(node, context) && component && component.vShow) {
+            hiddenPropName = component.vShow;
+        }
+        push(` ${hiddenPropName}="{{!${prop.exp.content}}}"`);
+    }
+    else if (prop.arg && prop.exp) {
+        const arg = prop.arg.content;
+        const exp = prop.exp.content;
+        push(` ${arg}="{{${exp}}}"`);
+    }
+    else {
+        throw new Error(`unknown directive` + JSON.stringify(prop));
+    }
+}

package/dist/transform.d.ts

@@ -0,0 +1,73 @@
+import { DirectiveNode, ElementNode, Property, RootNode, ParentNode, TemplateChildNode, CompilerError, ExpressionNode, JSChildNode, CacheExpression } from '@vue/compiler-core';
+import { CodegenRootNode, CodegenRootScope, CodegenScope, CodegenVForScope, CodegenVForScopeInit, CodegenVIfScope, CodegenVIfScopeInit, TransformOptions } from './options';
+export interface ImportItem {
+    exp: string | ExpressionNode;
+    path: string;
+}
+export declare type NodeTransform = (node: RootNode | TemplateChildNode, context: TransformContext) => void | (() => void) | (() => void)[];
+export declare type DirectiveTransform = (dir: DirectiveNode, node: ElementNode, context: TransformContext, augmentor?: (ret: DirectiveTransformResult) => DirectiveTransformResult) => DirectiveTransformResult;
+interface DirectiveTransformResult {
+    props: Property[];
+    needRuntime?: boolean | symbol;
+}
+export interface ErrorHandlingOptions {
+    onWarn?: (warning: CompilerError) => void;
+    onError?: (error: CompilerError) => void;
+}
+export declare const enum BindingComponentTypes {
+    SELF = "self",
+    SETUP = "setup",
+    UNKNOWN = "unknown"
+}
+export interface TransformContext extends Required<Omit<TransformOptions, 'filename' | 'root'>> {
+    selfName: string | null;
+    currentNode: RootNode | TemplateChildNode | null;
+    parent: ParentNode | null;
+    childIndex: number;
+    helpers: Map<symbol, number>;
+    components: Set<string>;
+    imports: ImportItem[];
+    bindingComponents: Record<string, {
+        type: BindingComponentTypes;
+        name: string;
+    }>;
+    identifiers: {
+        [name: string]: number | undefined;
+    };
+    cached: number;
+    scopes: {
+        vFor: number;
+        vueId: number;
+    };
+    scope: CodegenRootScope;
+    currentScope: CodegenScope;
+    currentVueId: string;
+    vueIds: string[];
+    inVOnce: boolean;
+    inVFor: boolean;
+    helper<T extends symbol>(name: T): T;
+    removeHelper<T extends symbol>(name: T): void;
+    helperString(name: symbol): string;
+    replaceNode(node: TemplateChildNode): void;
+    removeNode(node?: TemplateChildNode): void;
+    onNodeRemoved(): void;
+    addIdentifiers(exp: ExpressionNode | string): void;
+    removeIdentifiers(exp: ExpressionNode | string): void;
+    popScope(): CodegenScope | undefined;
+    getScopeIndex(scope: CodegenScope): number;
+    addVIfScope(initScope: CodegenVIfScopeInit): CodegenVIfScope;
+    addVForScope(initScope: CodegenVForScopeInit): CodegenVForScope;
+    cache<T extends JSChildNode>(exp: T, isVNode?: boolean): CacheExpression | T;
+    isMiniProgramComponent(name: string): boolean;
+}
+export declare function isRootScope(scope: CodegenScope): scope is CodegenRootScope;
+export declare function isVIfScope(scope: CodegenScope): scope is CodegenVIfScope;
+export declare function isVForScope(scope: CodegenScope): scope is CodegenVForScope;
+export declare function isScopedSlotVFor({ source }: CodegenVForScope): boolean;
+export declare function transform(root: CodegenRootNode, options: TransformOptions): TransformContext;
+export declare function traverseNode(node: RootNode | TemplateChildNode, context: TransformContext): void;
+export declare function traverseChildren(parent: ParentNode, context: TransformContext): void;
+export declare function createTransformContext(rootNode: RootNode, { root, filename, isTS, inline, hashId, scopeId, filters, bindingCssVars, bindingMetadata, cacheHandlers, prefixIdentifiers, skipTransformIdentifier, renderDataSpread, nodeTransforms, directiveTransforms, miniProgram, isBuiltInComponent, isCustomElement, expressionPlugins, onError, onWarn, }: TransformOptions): TransformContext;
+export declare type StructuralDirectiveTransform = (node: ElementNode, dir: DirectiveNode, context: TransformContext) => void | (() => void);
+export declare function createStructuralDirectiveTransform(name: string | RegExp, fn: StructuralDirectiveTransform): NodeTransform;
+export {};