@dcloudio/uni-app-uts 3.0.0-3080720230630001

package/dist/plugins/uvue/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/compiler/index.d.ts

@@ -0,0 +1,9 @@
+import './runtimeHelpers';
+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/compiler/index.js

@@ -0,0 +1,65 @@
+"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 uni_shared_1 = require("@dcloudio/uni-shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+require("./runtimeHelpers");
+const codegen_1 = require("./codegen");
+const transform_1 = require("./transform");
+const vIf_1 = require("./transforms/vIf");
+const vFor_1 = require("./transforms/vFor");
+const vModel_1 = require("./transforms/vModel");
+const vShow_1 = require("./transforms/vShow");
+const vText_1 = require("./transforms/vText");
+const transformInterpolation_1 = require("./transforms/transformInterpolation");
+const transformText_1 = require("./transforms/transformText");
+const vOn_1 = require("./transforms/vOn");
+const vBind_1 = require("./transforms/vBind");
+const transformSlotOutlet_1 = require("./transforms/transformSlotOutlet");
+function getBaseTransformPreset(prefixIdentifiers) {
+    return [
+        [
+            vIf_1.transformIf,
+            vFor_1.transformFor,
+            // order is important
+            compiler_core_1.trackVForSlotScopes,
+            compiler_core_1.transformExpression,
+            transformSlotOutlet_1.transformSlotOutlet,
+            compiler_core_1.transformElement,
+            compiler_core_1.trackSlotScopes,
+            transformText_1.transformText,
+            uni_cli_shared_1.transformTapToClick,
+            transformInterpolation_1.transformInterpolation,
+        ],
+        {
+            on: vOn_1.transformOn,
+            bind: vBind_1.transformBind,
+            model: vModel_1.transformModel,
+            show: vShow_1.transformShow,
+            text: vText_1.transformVText,
+        },
+    ];
+}
+exports.getBaseTransformPreset = getBaseTransformPreset;
+function compile(template, options) {
+    const ast = (0, compiler_core_1.baseParse)(template, {
+        isNativeTag(tag) {
+            return ((0, uni_shared_1.isAppUVueNativeTag)(tag) ||
+                !!options.parseUTSComponent?.(tag, options.targetLanguage));
+        },
+    });
+    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;

package/dist/plugins/uvue/compiler/options.d.ts

@@ -0,0 +1,92 @@
+import { BindingMetadata, CompilerError } from '@vue/compiler-core';
+import { RawSourceMap } from 'source-map';
+import { DirectiveTransform, NodeTransform } from './transform';
+interface SharedTransformCodegenOptions {
+    targetLanguage: 'kotlin' | 'swift';
+    /**
+     * Transform expressions like {{ foo }} to `_ctx.foo`.
+     * @default false
+     */
+    prefixIdentifiers?: boolean;
+    /**
+     * Optional binding metadata analyzed from script - used to optimize
+     * binding access when `prefixIdentifiers` is enabled.
+     */
+    bindingMetadata?: BindingMetadata;
+    /**
+     * Filename for source map generation.
+     * Also used for self-recursive reference in templates
+     * @default ''
+     */
+    filename?: string;
+}
+export interface CodegenOptions extends SharedTransformCodegenOptions {
+    /**
+     * function
+     * @default 'default'
+     */
+    mode?: 'default' | 'function';
+    /**
+     * Generate source map?
+     * @default false
+     */
+    sourceMap?: boolean;
+    /**
+     * 匹配 easycom 组件
+     * @param tag
+     */
+    matchEasyCom?: (tag: string, uts: boolean) => string | false | undefined | void;
+    /**
+     * 解析 uts component 组件
+     * @param name
+     * @param type
+     */
+    parseUTSComponent?: (name: string, type: 'kotlin' | 'swift') => {
+        className: string;
+        namespace: string;
+        source: string;
+    } | undefined | void;
+}
+export interface ErrorHandlingOptions {
+    onWarn?: (warning: CompilerError) => void;
+    onError?: (error: CompilerError) => void;
+}
+export interface TransformOptions extends SharedTransformCodegenOptions, ErrorHandlingOptions {
+    /**
+     * An array of node transforms to be applied to every AST node.
+     */
+    nodeTransforms?: NodeTransform[];
+    /**
+     * An object of { name: transform } to be applied to every directive attribute
+     * node found on element nodes.
+     */
+    directiveTransforms?: Record<string, DirectiveTransform | undefined>;
+    /**
+     * If the pairing runtime provides additional built-in elements, use this to
+     * mark them as built-in so the compiler will generate component vnodes
+     * for them.
+     */
+    isBuiltInComponent?: (tag: string) => symbol | void;
+    /**
+     * Used by some transforms that expects only native elements
+     */
+    isCustomElement?: (tag: string) => boolean | void;
+    /**
+     * SFC scoped styles ID
+     */
+    scopeId?: string | null;
+    /**
+     * Indicates this SFC template has used :slotted in its styles
+     * Defaults to `true` for backwards compatibility - SFC tooling should set it
+     * to `false` if no `:slotted` usage is detected in `<style>`
+     */
+    slotted?: boolean;
+}
+export type CompilerOptions = TransformOptions & CodegenOptions;
+export interface CodegenResult {
+    code: string;
+    importEasyComponents: string[];
+    importUTSComponents: string[];
+    map?: RawSourceMap;
+}
+export {};

package/dist/plugins/uvue/compiler/options.js

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

package/dist/plugins/uvue/compiler/runtimeHelpers.d.ts

@@ -0,0 +1,10 @@
+export declare const IS_TRUE: unique symbol;
+export declare const V_SHOW: unique symbol;
+export declare const RENDER_LIST: unique symbol;
+export declare const FRAGMENT: unique symbol;
+export declare const OPEN_BLOCK: unique symbol;
+export declare const RESOLVE_COMPONENT: unique symbol;
+export declare const RESOLVE_DIRECTIVE: unique symbol;
+export declare const RESOLVE_EASY_COMPONENT: unique symbol;
+export declare const RENDER_SLOT: unique symbol;
+export declare const TO_HANDLERS: unique symbol;

package/dist/plugins/uvue/compiler/runtimeHelpers.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TO_HANDLERS = exports.RENDER_SLOT = exports.RESOLVE_EASY_COMPONENT = exports.RESOLVE_DIRECTIVE = exports.RESOLVE_COMPONENT = exports.OPEN_BLOCK = exports.FRAGMENT = exports.RENDER_LIST = exports.V_SHOW = exports.IS_TRUE = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+exports.IS_TRUE = Symbol(`isTrue`);
+exports.V_SHOW = Symbol(`vShow`);
+exports.RENDER_LIST = Symbol(`renderList`);
+exports.FRAGMENT = Symbol(`Fragment`);
+exports.OPEN_BLOCK = Symbol(`openBlock`);
+exports.RESOLVE_COMPONENT = Symbol(`resolveComponent`);
+exports.RESOLVE_DIRECTIVE = Symbol(`resolveDirective`);
+exports.RESOLVE_EASY_COMPONENT = Symbol(`resolveEasyComponent`);
+exports.RENDER_SLOT = Symbol(`renderSlot`);
+exports.TO_HANDLERS = Symbol(`toHandlers`);
+(0, compiler_core_1.registerRuntimeHelpers)({
+    [exports.IS_TRUE]: 'isTrue',
+    [exports.V_SHOW]: 'vShow',
+    [exports.RENDER_LIST]: 'RenderHelpers.renderList',
+    [exports.FRAGMENT]: 'Fragment',
+    [exports.RESOLVE_COMPONENT]: 'resolveComponent',
+    [exports.RESOLVE_EASY_COMPONENT]: 'resolveEasyComponent',
+    [exports.RESOLVE_DIRECTIVE]: 'resolveDirective',
+    [exports.RENDER_SLOT]: `renderSlot`,
+    [exports.TO_HANDLERS]: `toHandlers`,
+});

package/dist/plugins/uvue/compiler/transform.d.ts

@@ -0,0 +1,53 @@
+import { CacheExpression, ComponentNode, ConstantTypes, DirectiveNode, ElementNode, ExpressionNode, JSChildNode, ParentNode, PlainElementNode, Property, RootNode, TemplateChildNode, TemplateLiteral, TemplateNode } from '@vue/compiler-core';
+import { TransformOptions } from './options';
+export type NodeTransform = (node: RootNode | TemplateChildNode, context: TransformContext) => void | (() => void) | (() => void)[];
+export type DirectiveTransform = (dir: DirectiveNode, node: ElementNode, context: TransformContext, augmentor?: (ret: DirectiveTransformResult) => DirectiveTransformResult) => DirectiveTransformResult;
+export interface DirectiveTransformResult {
+    props: Property[];
+    needRuntime?: boolean | symbol;
+    ssrTagParts?: TemplateLiteral['elements'];
+}
+export type StructuralDirectiveTransform = (node: ElementNode, dir: DirectiveNode, context: TransformContext) => void | (() => void);
+export interface ImportItem {
+    exp: string | ExpressionNode;
+    path: string;
+}
+export interface TransformContext extends Required<Omit<TransformOptions, 'filename'>> {
+    selfName: string | null;
+    root: RootNode;
+    helpers: Map<symbol, number>;
+    components: Set<string>;
+    directives: Set<string>;
+    imports: ImportItem[];
+    temps: number;
+    cached: number;
+    identifiers: {
+        [name: string]: number | undefined;
+    };
+    scopes: {
+        vFor: number;
+        vSlot: number;
+        vPre: number;
+        vOnce: number;
+    };
+    parent: ParentNode | null;
+    childIndex: number;
+    currentNode: RootNode | TemplateChildNode | null;
+    inVOnce: 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;
+    cache<T extends JSChildNode>(exp: T, isVNode?: boolean): CacheExpression | T;
+    constantCache: Map<TemplateChildNode, ConstantTypes>;
+}
+export declare function createTransformContext(root: RootNode, { targetLanguage, filename, prefixIdentifiers, nodeTransforms, directiveTransforms, scopeId, slotted, isBuiltInComponent, isCustomElement, onError, onWarn, }: TransformOptions): TransformContext;
+export declare function transform(root: RootNode, options: TransformOptions): void;
+export declare function isSingleElementRoot(root: RootNode, child: TemplateChildNode): child is PlainElementNode | ComponentNode | TemplateNode;
+export declare function traverseChildren(parent: ParentNode, context: TransformContext): void;
+export declare function traverseNode(node: RootNode | TemplateChildNode, context: TransformContext): void;
+export declare function createStructuralDirectiveTransform(name: string | RegExp, fn: StructuralDirectiveTransform): NodeTransform;

package/dist/plugins/uvue/compiler/transform.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStructuralDirectiveTransform = exports.traverseNode = exports.traverseChildren = exports.isSingleElementRoot = exports.transform = exports.createTransformContext = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+const shared_1 = require("@vue/shared");
+const errors_1 = require("./errors");
+const runtimeHelpers_1 = require("./runtimeHelpers");
+function createTransformContext(root, { targetLanguage, filename = '', prefixIdentifiers = false, nodeTransforms = [], directiveTransforms = {}, scopeId = null, slotted = true, isBuiltInComponent = shared_1.NOOP, isCustomElement = shared_1.NOOP, onError = errors_1.defaultOnError, onWarn = errors_1.defaultOnWarn, }) {
+    const nameMatch = filename.replace(/\?.*$/, '').match(/([^/\\]+)\.\w+$/);
+    const context = {
+        // options
+        targetLanguage,
+        selfName: nameMatch && (0, shared_1.capitalize)((0, shared_1.camelize)(nameMatch[1])),
+        prefixIdentifiers,
+        bindingMetadata: {},
+        nodeTransforms,
+        directiveTransforms,
+        isBuiltInComponent,
+        isCustomElement,
+        scopeId,
+        slotted,
+        onError,
+        onWarn,
+        // state
+        root,
+        helpers: new Map(),
+        components: new Set(),
+        directives: new Set(),
+        imports: [],
+        constantCache: new Map(),
+        temps: 0,
+        cached: 0,
+        identifiers: Object.create(null),
+        scopes: {
+            vFor: 0,
+            vSlot: 0,
+            vPre: 0,
+            vOnce: 0,
+        },
+        parent: null,
+        currentNode: root,
+        childIndex: 0,
+        inVOnce: false,
+        // methods
+        helper(name) {
+            const count = context.helpers.get(name) || 0;
+            context.helpers.set(name, count + 1);
+            return name;
+        },
+        removeHelper(name) {
+            const count = context.helpers.get(name);
+            if (count) {
+                const currentCount = count - 1;
+                if (!currentCount) {
+                    context.helpers.delete(name);
+                }
+                else {
+                    context.helpers.set(name, currentCount);
+                }
+            }
+        },
+        helperString(name) {
+            // return `_${helperNameMap[context.helper(name)]}`
+            return `${compiler_core_1.helperNameMap[context.helper(name)]}`;
+        },
+        replaceNode(node) {
+            if (!context.currentNode) {
+                throw new Error(`Node being replaced is already removed.`);
+            }
+            if (!context.parent) {
+                throw new Error(`Cannot replace root node.`);
+            }
+            context.parent.children[context.childIndex] = context.currentNode = node;
+        },
+        removeNode(node) {
+            if (!context.parent) {
+                throw new Error(`Cannot remove root node.`);
+            }
+            const list = context.parent.children;
+            const removalIndex = node
+                ? list.indexOf(node)
+                : context.currentNode
+                    ? context.childIndex
+                    : -1;
+            /* istanbul ignore if */
+            if (removalIndex < 0) {
+                throw new Error(`node being removed is not a child of current parent`);
+            }
+            if (!node || node === context.currentNode) {
+                // current node removed
+                context.currentNode = null;
+                context.onNodeRemoved();
+            }
+            else {
+                // sibling node removed
+                if (context.childIndex > removalIndex) {
+                    context.childIndex--;
+                    context.onNodeRemoved();
+                }
+            }
+            context.parent.children.splice(removalIndex, 1);
+        },
+        onNodeRemoved: () => { },
+        addIdentifiers(exp) {
+            // identifier tracking only happens in non-browser builds.
+            if ((0, shared_1.isString)(exp)) {
+                addId(exp);
+            }
+            else if (exp.identifiers) {
+                exp.identifiers.forEach(addId);
+            }
+            else if (exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {
+                addId(exp.content);
+            }
+        },
+        removeIdentifiers(exp) {
+            if ((0, shared_1.isString)(exp)) {
+                removeId(exp);
+            }
+            else if (exp.identifiers) {
+                exp.identifiers.forEach(removeId);
+            }
+            else if (exp.type === 4 /* NodeTypes.SIMPLE_EXPRESSION */) {
+                removeId(exp.content);
+            }
+        },
+        cache(exp, isVNode = false) {
+            return (0, compiler_core_1.createCacheExpression)(context.cached++, exp, isVNode);
+        },
+    };
+    function addId(id) {
+        const { identifiers } = context;
+        if (identifiers[id] === undefined) {
+            identifiers[id] = 0;
+        }
+        identifiers[id]++;
+    }
+    function removeId(id) {
+        context.identifiers[id]--;
+    }
+    return context;
+}
+exports.createTransformContext = createTransformContext;
+function transform(root, options) {
+    const context = createTransformContext(root, options);
+    traverseNode(root, context);
+    createRootCodegen(root, context);
+    root.components = [...context.components];
+}
+exports.transform = transform;
+function isSingleElementRoot(root, child) {
+    const { children } = root;
+    return (children.length === 1 &&
+        child.type === 1 /* NodeTypes.ELEMENT */ &&
+        !(0, compiler_core_1.isSlotOutlet)(child));
+}
+exports.isSingleElementRoot = isSingleElementRoot;
+function createRootCodegen(root, context) {
+    const { helper } = context;
+    const { children } = root;
+    if (children.length === 1) {
+        const child = children[0];
+        // if the single child is an element, turn it into a block.
+        if (isSingleElementRoot(root, child) && child.codegenNode) {
+            // single element root is never hoisted so codegenNode will never be
+            // SimpleExpressionNode
+            const codegenNode = child.codegenNode;
+            if (codegenNode.type === 13 /* NodeTypes.VNODE_CALL */) {
+                (0, compiler_core_1.makeBlock)(codegenNode, context);
+            }
+            root.codegenNode = codegenNode;
+        }
+        else {
+            // - single <slot/>, IfNode, ForNode: already blocks.
+            // - single text node: always patched.
+            // root codegen falls through via genNode()
+            root.codegenNode = child;
+        }
+    }
+    else if (children.length > 1) {
+        // root has multiple nodes - return a fragment block.
+        let patchFlag = 64 /* PatchFlags.STABLE_FRAGMENT */;
+        let patchFlagText = shared_1.PatchFlagNames[64 /* PatchFlags.STABLE_FRAGMENT */];
+        // check if the fragment actually contains a single valid child with
+        // the rest being comments
+        if (children.filter((c) => c.type !== 3 /* NodeTypes.COMMENT */).length === 1) {
+            patchFlag |= 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */;
+            patchFlagText += `, ${shared_1.PatchFlagNames[2048 /* PatchFlags.DEV_ROOT_FRAGMENT */]}`;
+        }
+        root.codegenNode = (0, compiler_core_1.createVNodeCall)(
+        // @ts-ignore
+        context, helper(runtimeHelpers_1.FRAGMENT), undefined, root.children, patchFlag + ` /* ${patchFlagText} */`, undefined, undefined, true, undefined, false /* isComponent */);
+    }
+    else {
+        // no children = noop. codegen will return null.
+    }
+}
+function traverseChildren(parent, context) {
+    let i = 0;
+    const nodeRemoved = () => {
+        i--;
+    };
+    for (; i < parent.children.length; i++) {
+        const child = parent.children[i];
+        if ((0, shared_1.isString)(child))
+            continue;
+        context.parent = parent;
+        context.childIndex = i;
+        context.onNodeRemoved = nodeRemoved;
+        traverseNode(child, context);
+    }
+}
+exports.traverseChildren = traverseChildren;
+function traverseNode(node, context) {
+    context.currentNode = node;
+    // apply transform plugins
+    const { nodeTransforms } = context;
+    const exitFns = [];
+    for (let i = 0; i < nodeTransforms.length; i++) {
+        const onExit = nodeTransforms[i](node, context);
+        if (onExit) {
+            if ((0, shared_1.isArray)(onExit)) {
+                exitFns.push(...onExit);
+            }
+            else {
+                exitFns.push(onExit);
+            }
+        }
+        if (!context.currentNode) {
+            // node was removed
+            return;
+        }
+        else {
+            // node may have been replaced
+            node = context.currentNode;
+        }
+    }
+    switch (node.type) {
+        case 3 /* NodeTypes.COMMENT */:
+            break;
+        case 5 /* NodeTypes.INTERPOLATION */:
+            break;
+        // for container types, further traverse downwards
+        case 9 /* NodeTypes.IF */:
+            for (let i = 0; i < node.branches.length; i++) {
+                traverseNode(node.branches[i], context);
+            }
+            break;
+        case 10 /* NodeTypes.IF_BRANCH */:
+        case 11 /* NodeTypes.FOR */:
+        case 1 /* NodeTypes.ELEMENT */:
+        case 0 /* NodeTypes.ROOT */:
+            traverseChildren(node, context);
+            break;
+    }
+    // exit transforms
+    context.currentNode = node;
+    let i = exitFns.length;
+    while (i--) {
+        exitFns[i]();
+    }
+}
+exports.traverseNode = traverseNode;
+function createStructuralDirectiveTransform(name, fn) {
+    const matches = (0, shared_1.isString)(name)
+        ? (n) => n === name
+        : (n) => name.test(n);
+    return (node, context) => {
+        if (node.type === 1 /* NodeTypes.ELEMENT */) {
+            const { props } = node;
+            // structural directive transforms are not concerned with slots
+            // as they are handled separately in vSlot.ts
+            if (node.tagType === 3 /* ElementTypes.TEMPLATE */ && props.some(compiler_core_1.isVSlot)) {
+                return;
+            }
+            const exitFns = [];
+            for (let i = 0; i < props.length; i++) {
+                const prop = props[i];
+                if (prop.type === 7 /* NodeTypes.DIRECTIVE */ && matches(prop.name)) {
+                    // structural directives are removed to avoid infinite recursion
+                    // also we remove them *before* applying so that it can further
+                    // traverse itself in case it moves the node around
+                    props.splice(i, 1);
+                    i--;
+                    const onExit = fn(node, prop, context);
+                    if (onExit)
+                        exitFns.push(onExit);
+                }
+            }
+            return exitFns;
+        }
+    };
+}
+exports.createStructuralDirectiveTransform = createStructuralDirectiveTransform;

package/dist/plugins/uvue/compiler/transforms/transformExpression.d.ts

@@ -0,0 +1,5 @@
+import { NodeTransform, TransformContext } from '../transform';
+import { ExpressionNode, SimpleExpressionNode } from '@vue/compiler-core';
+export declare const transformExpression: NodeTransform;
+export declare function processExpression(node: SimpleExpressionNode, context: TransformContext, asParams?: boolean, asRawStatements?: boolean, localVars?: Record<string, number>): ExpressionNode;
+export declare function stringifyExpression(exp: ExpressionNode | string): string;