@dcloudio/uni-app-uts 3.0.0-alpha-3071320230417001

package/dist/plugins/uvue/code/template/compiler/codegen.d.ts

@@ -0,0 +1,20 @@
+import { SourceMapGenerator } from 'source-map';
+import { JSChildNode, RootNode, SSRCodegenNode, TemplateChildNode } from '@vue/compiler-core';
+import { CodegenOptions, CodegenResult } from './options';
+type CodegenNode = TemplateChildNode | JSChildNode | SSRCodegenNode;
+export interface CodegenContext extends Required<CodegenOptions> {
+    source: string;
+    code: string;
+    line: number;
+    column: number;
+    offset: number;
+    indentLevel: number;
+    map?: SourceMapGenerator;
+    helper(key: symbol): string;
+    push(code: string, node?: CodegenNode): void;
+    indent(): void;
+    deindent(withoutNewLine?: boolean): void;
+    newline(): void;
+}
+export declare function generate(ast: RootNode, options: CodegenOptions): CodegenResult;
+export {};

package/dist/plugins/uvue/code/template/compiler/codegen.js

@@ -0,0 +1,419 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = void 0;
+const source_map_1 = require("source-map");
+const compiler_core_1 = require("@vue/compiler-core");
+const shared_1 = require("@vue/shared");
+const utils_1 = require("../utils");
+function createCodegenContext(ast, { targetLanguage, mode = 'default', prefixIdentifiers = false, sourceMap = false, filename = '', }) {
+    const context = {
+        targetLanguage,
+        mode,
+        prefixIdentifiers,
+        sourceMap,
+        filename,
+        source: ast.loc.source,
+        code: ``,
+        column: 1,
+        line: 1,
+        offset: 0,
+        indentLevel: 0,
+        map: undefined,
+        helper(key) {
+            return `${compiler_core_1.helperNameMap[key]}`;
+        },
+        push(code, node) {
+            context.code += code;
+            if (context.map) {
+                if (node) {
+                    let name;
+                    if (node.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ && !node.isStatic) {
+                        const content = node.content.replace(/^_ctx\./, '');
+                        if (content !== node.content && (0, compiler_core_1.isSimpleIdentifier)(content)) {
+                            name = content;
+                        }
+                    }
+                    addMapping(node.loc.start, name);
+                }
+                (0, compiler_core_1.advancePositionWithMutation)(context, code);
+                if (node && node.loc !== compiler_core_1.locStub) {
+                    addMapping(node.loc.end);
+                }
+            }
+        },
+        indent() {
+            newline(++context.indentLevel);
+        },
+        deindent(withoutNewLine = false) {
+            if (withoutNewLine) {
+                --context.indentLevel;
+            }
+            else {
+                newline(--context.indentLevel);
+            }
+        },
+        newline() {
+            newline(context.indentLevel);
+        },
+    };
+    function newline(n) {
+        context.push('\n' + `  `.repeat(n));
+    }
+    function addMapping(loc, name) {
+        context.map.addMapping({
+            name,
+            source: context.filename,
+            original: {
+                line: loc.line,
+                column: loc.column - 1, // source-map column is 0 based
+            },
+            generated: {
+                line: context.line,
+                column: context.column - 1,
+            },
+        });
+    }
+    if (sourceMap) {
+        // lazy require source-map implementation, only in non-browser builds
+        context.map = new source_map_1.SourceMapGenerator();
+        context.map.setSourceContent(filename, context.source);
+    }
+    return context;
+}
+function generate(ast, options) {
+    const context = createCodegenContext(ast, options);
+    const { mode, deindent, indent, push } = context;
+    if (mode === 'function') {
+        push((0, utils_1.genRenderFunctionDecl)(options) + ` {`);
+        indent();
+        push(`return `);
+    }
+    if (ast.codegenNode) {
+        genNode(ast.codegenNode, context);
+    }
+    else {
+        push(`null`);
+    }
+    if (mode === 'function') {
+        deindent();
+        push(`}`);
+    }
+    return {
+        code: context.code,
+        // SourceMapGenerator does have toJSON() method but it's not in the types
+        map: context.map ? context.map.toJSON() : undefined,
+    };
+}
+exports.generate = generate;
+function isText(n) {
+    return ((0, shared_1.isString)(n) ||
+        n.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */ ||
+        n.type === 2 /* NodeTypes.TEXT */ ||
+        n.type === 5 /* NodeTypes.INTERPOLATION */ ||
+        n.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */);
+}
+function genNodeListAsArray(nodes, context) {
+    const multilines = nodes.length > 3 || nodes.some((n) => (0, shared_1.isArray)(n) || !isText(n));
+    context.push(`[`);
+    multilines && context.indent();
+    genNodeList(nodes, context, multilines);
+    multilines && context.deindent();
+    context.push(`]`);
+}
+function genNodeList(nodes, context, multilines = false, comma = true) {
+    const { push, newline } = context;
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        if ((0, shared_1.isString)(node)) {
+            push(node);
+        }
+        else if ((0, shared_1.isArray)(node)) {
+            genNodeListAsArray(node, context);
+        }
+        else {
+            genNode(node, context);
+        }
+        if (i < nodes.length - 1) {
+            if (multilines) {
+                comma && push(',');
+                newline();
+            }
+            else {
+                comma && push(', ');
+            }
+        }
+    }
+}
+function genNode(node, context) {
+    if ((0, shared_1.isString)(node)) {
+        context.push(node);
+        return;
+    }
+    if ((0, shared_1.isSymbol)(node)) {
+        return;
+    }
+    switch (node.type) {
+        case 1 /* NodeTypes.ELEMENT */:
+        case 9 /* NodeTypes.IF */:
+        case 11 /* NodeTypes.FOR */:
+            genNode(node.codegenNode, context);
+            break;
+        case 2 /* NodeTypes.TEXT */:
+            genText(node, context);
+            break;
+        case 4 /* NodeTypes.SIMPLE_EXPRESSION */:
+            genExpression(node, context);
+            break;
+        case 5 /* NodeTypes.INTERPOLATION */:
+            genInterpolation(node, context);
+            break;
+        case 12 /* NodeTypes.TEXT_CALL */:
+            genNode(node.codegenNode, context);
+            break;
+        case 8 /* NodeTypes.COMPOUND_EXPRESSION */:
+            genCompoundExpression(node, context);
+            break;
+        case 3 /* NodeTypes.COMMENT */:
+            genComment(node, context);
+            break;
+        case 13 /* NodeTypes.VNODE_CALL */:
+            genVNodeCall(node, context);
+            break;
+        case 14 /* NodeTypes.JS_CALL_EXPRESSION */:
+            genCallExpression(node, context);
+            break;
+        case 15 /* NodeTypes.JS_OBJECT_EXPRESSION */:
+            genObjectExpression(node, context);
+            break;
+        case 17 /* NodeTypes.JS_ARRAY_EXPRESSION */:
+            genArrayExpression(node, context);
+            break;
+        case 18 /* NodeTypes.JS_FUNCTION_EXPRESSION */:
+            genFunctionExpression(node, context);
+            break;
+        case 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */:
+            genConditionalExpression(node, context);
+            break;
+        case 20 /* NodeTypes.JS_CACHE_EXPRESSION */:
+            genCacheExpression(node, context);
+            break;
+        /* istanbul ignore next */
+        case 10 /* NodeTypes.IF_BRANCH */:
+            // noop
+            break;
+        default:
+    }
+}
+function genText(node, context) {
+    context.push(JSON.stringify(node.content), node);
+}
+function genExpression(node, context) {
+    const { content, isStatic } = node;
+    context.push(isStatic ? JSON.stringify(content) : content, node);
+}
+function genInterpolation(node, context) {
+    const { push, helper } = context;
+    push(`${helper(compiler_core_1.TO_DISPLAY_STRING)}(`);
+    genNode(node.content, context);
+    push(`)`);
+}
+function genCompoundExpression(node, context) {
+    for (let i = 0; i < node.children.length; i++) {
+        const child = node.children[i];
+        if ((0, shared_1.isString)(child)) {
+            context.push(child);
+        }
+        else {
+            genNode(child, context);
+        }
+    }
+}
+function genExpressionAsPropertyKey(node, context) {
+    const { push } = context;
+    if (node.type === 8 /* NodeTypes.COMPOUND_EXPRESSION */) {
+        push(`[`);
+        genCompoundExpression(node, context);
+        push(`]`);
+    }
+    else if (node.isStatic) {
+        // only quote keys if necessary
+        const text = JSON.stringify(node.content);
+        push(text, node);
+    }
+    else {
+        push(`[${node.content}]`, node);
+    }
+}
+function genComment(node, context) {
+    const { push, helper } = context;
+    push(`${helper(compiler_core_1.CREATE_COMMENT)}(${JSON.stringify(node.content)})`, node);
+}
+function genVNodeCall(node, context) {
+    const { push, helper } = context;
+    const { tag, props, children, patchFlag, dynamicProps, directives, 
+    // isBlock,
+    disableTracking, isComponent, } = node;
+    if (directives) {
+        push(helper(compiler_core_1.WITH_DIRECTIVES) + `(`);
+    }
+    const isBlock = false;
+    if (isBlock) {
+        push(`(${helper(compiler_core_1.OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);
+    }
+    const callHelper = isBlock
+        ? (0, compiler_core_1.getVNodeBlockHelper)(false, isComponent)
+        : (0, compiler_core_1.getVNodeHelper)(false, isComponent);
+    push(helper(callHelper) + `(`, node);
+    genNodeList(genNullableArgs([tag, props, children, patchFlag, dynamicProps]), context);
+    push(`)`);
+    if (isBlock) {
+        push(`)`);
+    }
+    if (directives) {
+        push(`, `);
+        genNode(directives, context);
+        push(`)`);
+    }
+}
+function genNullableArgs(args) {
+    let i = args.length;
+    while (i--) {
+        if (args[i] != null)
+            break;
+    }
+    return args.slice(0, i + 1).map((arg) => arg || `null`);
+}
+// JavaScript
+function genCallExpression(node, context) {
+    const { push, helper } = context;
+    const callee = (0, shared_1.isString)(node.callee) ? node.callee : helper(node.callee);
+    push(callee + `(`, node);
+    genNodeList(node.arguments, context);
+    push(`)`);
+}
+function genObjectExpression(node, context) {
+    const { push, indent, deindent, newline } = context;
+    const { properties } = node;
+    if (!properties.length) {
+        push(`new Map<string,any>()`, node);
+        return;
+    }
+    const multilines = properties.length > 1 ||
+        properties.some((p) => p.value.type !== 4 /* NodeTypes.SIMPLE_EXPRESSION */);
+    push(`new Map<string,any>([`);
+    multilines && indent();
+    for (let i = 0; i < properties.length; i++) {
+        const { key, value } = properties[i];
+        push(`[`);
+        // key
+        genExpressionAsPropertyKey(key, context);
+        push(`, `);
+        // value
+        genNode(value, context);
+        push(`]`);
+        if (i < properties.length - 1) {
+            // will only reach this if it's multilines
+            push(`,`);
+            newline();
+        }
+    }
+    multilines && deindent();
+    push(`])`);
+}
+function genArrayExpression(node, context) {
+    genNodeListAsArray(node.elements, context);
+}
+function genFunctionExpression(node, context) {
+    const { push, indent, deindent } = context;
+    const { params, returns, body, newline, isSlot } = node;
+    if (isSlot) {
+        // wrap slot functions with owner context
+        push(`_${compiler_core_1.helperNameMap[compiler_core_1.WITH_CTX]}(`);
+    }
+    push(`(`, node);
+    if ((0, shared_1.isArray)(params)) {
+        genNodeList(params, context);
+    }
+    else if (params) {
+        genNode(params, context);
+    }
+    push(`) => `);
+    if (newline || body) {
+        push(`{`);
+        indent();
+    }
+    if (returns) {
+        if (newline) {
+            push(`return `);
+        }
+        if ((0, shared_1.isArray)(returns)) {
+            genNodeListAsArray(returns, context);
+        }
+        else {
+            genNode(returns, context);
+        }
+    }
+    else if (body) {
+        genNode(body, context);
+    }
+    if (newline || body) {
+        deindent();
+        push(`}`);
+    }
+    if (isSlot) {
+        push(`)`);
+    }
+}
+function genConditionalExpression(node, context) {
+    const { test, consequent, alternate, newline: needNewline } = node;
+    const { push, indent, deindent, newline } = context;
+    if (test.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {
+        const needsParens = !(0, compiler_core_1.isSimpleIdentifier)(test.content);
+        needsParens && push(`(`);
+        genExpression(test, context);
+        needsParens && push(`)`);
+    }
+    else {
+        push(`(`);
+        genNode(test, context);
+        push(`)`);
+    }
+    needNewline && indent();
+    context.indentLevel++;
+    needNewline || push(` `);
+    push(`? `);
+    genNode(consequent, context);
+    context.indentLevel--;
+    needNewline && newline();
+    needNewline || push(` `);
+    push(`: `);
+    const isNested = alternate.type === 19 /* NodeTypes.JS_CONDITIONAL_EXPRESSION */;
+    if (!isNested) {
+        context.indentLevel++;
+    }
+    genNode(alternate, context);
+    if (!isNested) {
+        context.indentLevel--;
+    }
+    needNewline && deindent(true /* without newline */);
+}
+function genCacheExpression(node, context) {
+    const { push, helper, indent, deindent, newline } = context;
+    push(`_cache[${node.index}] || (`);
+    if (node.isVNode) {
+        indent();
+        push(`${helper(compiler_core_1.SET_BLOCK_TRACKING)}(-1),`);
+        newline();
+    }
+    push(`_cache[${node.index}] = `);
+    genNode(node.value, context);
+    if (node.isVNode) {
+        push(`,`);
+        newline();
+        push(`${helper(compiler_core_1.SET_BLOCK_TRACKING)}(1),`);
+        newline();
+        push(`_cache[${node.index}]`);
+        deindent();
+    }
+    push(`)`);
+}

package/dist/plugins/uvue/code/template/compiler/errors.d.ts

@@ -0,0 +1,70 @@
+import { SourceLocation } from '@vue/compiler-core';
+export interface CompilerError extends SyntaxError {
+    code: number | string;
+    loc?: SourceLocation;
+}
+export interface CoreCompilerError extends CompilerError {
+    code: ErrorCodes;
+}
+export declare function defaultOnError(error: CompilerError): void;
+export declare function defaultOnWarn(msg: CompilerError): void;
+type InferCompilerError<T> = T extends ErrorCodes ? CoreCompilerError : CompilerError;
+export declare function createCompilerError<T extends number>(code: T, loc?: SourceLocation, messages?: {
+    [code: number]: string;
+}, additionalMessage?: string): InferCompilerError<T>;
+export declare const enum ErrorCodes {
+    ABRUPT_CLOSING_OF_EMPTY_COMMENT = 0,
+    CDATA_IN_HTML_CONTENT = 1,
+    DUPLICATE_ATTRIBUTE = 2,
+    END_TAG_WITH_ATTRIBUTES = 3,
+    END_TAG_WITH_TRAILING_SOLIDUS = 4,
+    EOF_BEFORE_TAG_NAME = 5,
+    EOF_IN_CDATA = 6,
+    EOF_IN_COMMENT = 7,
+    EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT = 8,
+    EOF_IN_TAG = 9,
+    INCORRECTLY_CLOSED_COMMENT = 10,
+    INCORRECTLY_OPENED_COMMENT = 11,
+    INVALID_FIRST_CHARACTER_OF_TAG_NAME = 12,
+    MISSING_ATTRIBUTE_VALUE = 13,
+    MISSING_END_TAG_NAME = 14,
+    MISSING_WHITESPACE_BETWEEN_ATTRIBUTES = 15,
+    NESTED_COMMENT = 16,
+    UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME = 17,
+    UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE = 18,
+    UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME = 19,
+    UNEXPECTED_NULL_CHARACTER = 20,
+    UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME = 21,
+    UNEXPECTED_SOLIDUS_IN_TAG = 22,
+    X_INVALID_END_TAG = 23,
+    X_MISSING_END_TAG = 24,
+    X_MISSING_INTERPOLATION_END = 25,
+    X_MISSING_DIRECTIVE_NAME = 26,
+    X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END = 27,
+    X_V_IF_NO_EXPRESSION = 28,
+    X_V_IF_SAME_KEY = 29,
+    X_V_ELSE_NO_ADJACENT_IF = 30,
+    X_V_FOR_NO_EXPRESSION = 31,
+    X_V_FOR_MALFORMED_EXPRESSION = 32,
+    X_V_FOR_TEMPLATE_KEY_PLACEMENT = 33,
+    X_V_BIND_NO_EXPRESSION = 34,
+    X_V_ON_NO_EXPRESSION = 35,
+    X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET = 36,
+    X_V_SLOT_MIXED_SLOT_USAGE = 37,
+    X_V_SLOT_DUPLICATE_SLOT_NAMES = 38,
+    X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN = 39,
+    X_V_SLOT_MISPLACED = 40,
+    X_V_MODEL_NO_EXPRESSION = 41,
+    X_V_MODEL_MALFORMED_EXPRESSION = 42,
+    X_V_MODEL_ON_SCOPE_VARIABLE = 43,
+    X_V_MODEL_ON_PROPS = 44,
+    X_INVALID_EXPRESSION = 45,
+    X_KEEP_ALIVE_INVALID_CHILDREN = 46,
+    X_PREFIX_ID_NOT_SUPPORTED = 47,
+    X_MODULE_MODE_NOT_SUPPORTED = 48,
+    X_CACHE_HANDLER_NOT_SUPPORTED = 49,
+    X_SCOPE_ID_NOT_SUPPORTED = 50,
+    __EXTEND_POINT__ = 51
+}
+export declare const errorMessages: Record<ErrorCodes, string>;
+export {};

package/dist/plugins/uvue/code/template/compiler/errors.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorMessages = exports.createCompilerError = exports.defaultOnWarn = exports.defaultOnError = void 0;
+function defaultOnError(error) {
+    throw error;
+}
+exports.defaultOnError = defaultOnError;
+function defaultOnWarn(msg) {
+    console.warn(`[Vue warn] ${msg.message}`);
+}
+exports.defaultOnWarn = defaultOnWarn;
+function createCompilerError(code, loc, messages, additionalMessage) {
+    const msg = (messages || exports.errorMessages)[code] + (additionalMessage || ``);
+    const error = new SyntaxError(String(msg));
+    error.code = code;
+    error.loc = loc;
+    return error;
+}
+exports.createCompilerError = createCompilerError;
+exports.errorMessages = {
+    // parse errors
+    [0 /* ErrorCodes.ABRUPT_CLOSING_OF_EMPTY_COMMENT */]: 'Illegal comment.',
+    [1 /* ErrorCodes.CDATA_IN_HTML_CONTENT */]: 'CDATA section is allowed only in XML context.',
+    [2 /* ErrorCodes.DUPLICATE_ATTRIBUTE */]: 'Duplicate attribute.',
+    [3 /* ErrorCodes.END_TAG_WITH_ATTRIBUTES */]: 'End tag cannot have attributes.',
+    [4 /* ErrorCodes.END_TAG_WITH_TRAILING_SOLIDUS */]: "Illegal '/' in tags.",
+    [5 /* ErrorCodes.EOF_BEFORE_TAG_NAME */]: 'Unexpected EOF in tag.',
+    [6 /* ErrorCodes.EOF_IN_CDATA */]: 'Unexpected EOF in CDATA section.',
+    [7 /* ErrorCodes.EOF_IN_COMMENT */]: 'Unexpected EOF in comment.',
+    [8 /* ErrorCodes.EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT */]: 'Unexpected EOF in script.',
+    [9 /* ErrorCodes.EOF_IN_TAG */]: 'Unexpected EOF in tag.',
+    [10 /* ErrorCodes.INCORRECTLY_CLOSED_COMMENT */]: 'Incorrectly closed comment.',
+    [11 /* ErrorCodes.INCORRECTLY_OPENED_COMMENT */]: 'Incorrectly opened comment.',
+    [12 /* ErrorCodes.INVALID_FIRST_CHARACTER_OF_TAG_NAME */]: "Illegal tag name. Use '&lt;' to print '<'.",
+    [13 /* ErrorCodes.MISSING_ATTRIBUTE_VALUE */]: 'Attribute value was expected.',
+    [14 /* ErrorCodes.MISSING_END_TAG_NAME */]: 'End tag name was expected.',
+    [15 /* ErrorCodes.MISSING_WHITESPACE_BETWEEN_ATTRIBUTES */]: 'Whitespace was expected.',
+    [16 /* ErrorCodes.NESTED_COMMENT */]: "Unexpected '<!--' in comment.",
+    [17 /* ErrorCodes.UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME */]: 'Attribute name cannot contain U+0022 ("), U+0027 (\'), and U+003C (<).',
+    [18 /* ErrorCodes.UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE */]: 'Unquoted attribute value cannot contain U+0022 ("), U+0027 (\'), U+003C (<), U+003D (=), and U+0060 (`).',
+    [19 /* ErrorCodes.UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME */]: "Attribute name cannot start with '='.",
+    [21 /* ErrorCodes.UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME */]: "'<?' is allowed only in XML context.",
+    [20 /* ErrorCodes.UNEXPECTED_NULL_CHARACTER */]: `Unexpected null character.`,
+    [22 /* ErrorCodes.UNEXPECTED_SOLIDUS_IN_TAG */]: "Illegal '/' in tags.",
+    // Vue-specific parse errors
+    [23 /* ErrorCodes.X_INVALID_END_TAG */]: 'Invalid end tag.',
+    [24 /* ErrorCodes.X_MISSING_END_TAG */]: 'Element is missing end tag.',
+    [25 /* ErrorCodes.X_MISSING_INTERPOLATION_END */]: 'Interpolation end sign was not found.',
+    [27 /* ErrorCodes.X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END */]: 'End bracket for dynamic directive argument was not found. ' +
+        'Note that dynamic directive argument cannot contain spaces.',
+    [26 /* ErrorCodes.X_MISSING_DIRECTIVE_NAME */]: 'Legal directive name was expected.',
+    // transform errors
+    [28 /* ErrorCodes.X_V_IF_NO_EXPRESSION */]: `v-if/v-else-if is missing expression.`,
+    [29 /* ErrorCodes.X_V_IF_SAME_KEY */]: `v-if/else branches must use unique keys.`,
+    [30 /* ErrorCodes.X_V_ELSE_NO_ADJACENT_IF */]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
+    [31 /* ErrorCodes.X_V_FOR_NO_EXPRESSION */]: `v-for is missing expression.`,
+    [32 /* ErrorCodes.X_V_FOR_MALFORMED_EXPRESSION */]: `v-for has invalid expression.`,
+    [33 /* ErrorCodes.X_V_FOR_TEMPLATE_KEY_PLACEMENT */]: `<template v-for> key should be placed on the <template> tag.`,
+    [34 /* ErrorCodes.X_V_BIND_NO_EXPRESSION */]: `v-bind is missing expression.`,
+    [35 /* ErrorCodes.X_V_ON_NO_EXPRESSION */]: `v-on is missing expression.`,
+    [36 /* ErrorCodes.X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET */]: `Unexpected custom directive on <slot> outlet.`,
+    [37 /* ErrorCodes.X_V_SLOT_MIXED_SLOT_USAGE */]: `Mixed v-slot usage on both the component and nested <template>. ` +
+        `When there are multiple named slots, all slots should use <template> ` +
+        `syntax to avoid scope ambiguity.`,
+    [38 /* ErrorCodes.X_V_SLOT_DUPLICATE_SLOT_NAMES */]: `Duplicate slot names found. `,
+    [39 /* ErrorCodes.X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN */]: `Extraneous children found when component already has explicitly named ` +
+        `default slot. These children will be ignored.`,
+    [40 /* ErrorCodes.X_V_SLOT_MISPLACED */]: `v-slot can only be used on components or <template> tags.`,
+    [41 /* ErrorCodes.X_V_MODEL_NO_EXPRESSION */]: `v-model is missing expression.`,
+    [42 /* ErrorCodes.X_V_MODEL_MALFORMED_EXPRESSION */]: `v-model value must be a valid JavaScript member expression.`,
+    [43 /* ErrorCodes.X_V_MODEL_ON_SCOPE_VARIABLE */]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
+    [44 /* ErrorCodes.X_V_MODEL_ON_PROPS */]: `v-model cannot be used on a prop, because local prop bindings are not writable.\nUse a v-bind binding combined with a v-on listener that emits update:x event instead.`,
+    [45 /* ErrorCodes.X_INVALID_EXPRESSION */]: `Error parsing JavaScript expression: `,
+    [46 /* ErrorCodes.X_KEEP_ALIVE_INVALID_CHILDREN */]: `<KeepAlive> expects exactly one child component.`,
+    // generic errors
+    [47 /* ErrorCodes.X_PREFIX_ID_NOT_SUPPORTED */]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
+    [48 /* ErrorCodes.X_MODULE_MODE_NOT_SUPPORTED */]: `ES module mode is not supported in this build of compiler.`,
+    [49 /* ErrorCodes.X_CACHE_HANDLER_NOT_SUPPORTED */]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
+    [50 /* ErrorCodes.X_SCOPE_ID_NOT_SUPPORTED */]: `"scopeId" option is only supported in module mode.`,
+    // just to fulfill types
+    [51 /* ErrorCodes.__EXTEND_POINT__ */]: ``,
+};

package/dist/plugins/uvue/code/template/compiler/index.d.ts

@@ -0,0 +1,8 @@
+import { CodegenResult, CompilerOptions } from './options';
+import { DirectiveTransform, NodeTransform } from './transform';
+export type TransformPreset = [
+    NodeTransform[],
+    Record<string, DirectiveTransform>
+];
+export declare function getBaseTransformPreset(prefixIdentifiers?: boolean): TransformPreset;
+export declare function compile(template: string, options: CompilerOptions): CodegenResult;

package/dist/plugins/uvue/code/template/compiler/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = exports.getBaseTransformPreset = void 0;
+const shared_1 = require("@vue/shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const codegen_1 = require("./codegen");
+const transform_1 = require("./transform");
+function getBaseTransformPreset(prefixIdentifiers) {
+    return [
+        [
+            // order is important
+            compiler_core_1.trackVForSlotScopes,
+            compiler_core_1.transformExpression,
+            compiler_core_1.transformElement,
+            compiler_core_1.trackSlotScopes,
+        ],
+        {
+            on: compiler_core_1.transformOn,
+            bind: compiler_core_1.transformBind,
+            model: compiler_core_1.transformModel,
+        },
+    ];
+}
+exports.getBaseTransformPreset = getBaseTransformPreset;
+function compile(template, options) {
+    const ast = (0, compiler_core_1.baseParse)(template, {
+        isCustomElement(tag) {
+            return true;
+        },
+    });
+    const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(options.prefixIdentifiers);
+    (0, transform_1.transform)(ast, (0, shared_1.extend)({}, options, {
+        prefixIdentifiers: options.prefixIdentifiers,
+        nodeTransforms: [
+            ...nodeTransforms,
+            ...(options.nodeTransforms || []), // user transforms
+        ],
+        directiveTransforms: (0, shared_1.extend)({}, directiveTransforms, options.directiveTransforms || {} // user transforms
+        ),
+    }));
+    return (0, codegen_1.generate)(ast, options);
+}
+exports.compile = compile;