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

package/dist/compile.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.baseCompile = exports.getBaseTransformPreset = void 0;
+const fs_1 = __importDefault(require("fs"));
+const compiler_core_1 = require("@vue/compiler-core");
+const shared_1 = require("@vue/shared");
+const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared");
+const codegen_1 = require("./codegen");
+const transform_1 = require("./transform");
+const transformExpression_1 = require("./transforms/transformExpression");
+const transformIdentifier_1 = require("./transforms/transformIdentifier");
+const vIf_1 = require("./transforms/vIf");
+const vFor_1 = require("./transforms/vFor");
+const codegen_2 = require("./template/codegen");
+const vOn_1 = require("./transforms/vOn");
+const transformElement_1 = require("./transforms/transformElement");
+const vBind_1 = require("./transforms/vBind");
+const transformComponent_1 = require("./transforms/transformComponent");
+const vSlot_1 = require("./transforms/vSlot");
+const transformRoot_1 = require("./transforms/transformRoot");
+const transformTag_1 = require("./transforms/transformTag");
+const vHtml_1 = require("./transforms/vHtml");
+function getBaseTransformPreset({ prefixIdentifiers, skipTransformIdentifier, }) {
+    // order is important
+    const nodeTransforms = [
+        transformRoot_1.transformRoot,
+        transformTag_1.transformTag,
+        vHtml_1.transformHtml,
+        vIf_1.transformIf,
+        vFor_1.transformFor,
+        vSlot_1.transformSlot,
+    ];
+    if (!skipTransformIdentifier) {
+        nodeTransforms.push(transformIdentifier_1.transformIdentifier);
+    }
+    nodeTransforms.push(transformElement_1.transformElement);
+    nodeTransforms.push(transformComponent_1.transformComponent);
+    if (prefixIdentifiers) {
+        nodeTransforms.push(transformExpression_1.transformExpression);
+    }
+    return [
+        nodeTransforms,
+        { on: vOn_1.transformOn, bind: vBind_1.transformBind },
+    ];
+}
+exports.getBaseTransformPreset = getBaseTransformPreset;
+function baseCompile(template, options = {}) {
+    var _a, _b;
+    const prefixIdentifiers = options.prefixIdentifiers === true || options.mode === 'module';
+    const ast = ((0, shared_1.isString)(template) ? (0, compiler_core_1.baseParse)(template, options) : template);
+    const [nodeTransforms, directiveTransforms] = getBaseTransformPreset({
+        prefixIdentifiers,
+        skipTransformIdentifier: options.skipTransformIdentifier === true,
+    });
+    options.hashId = genHashId(options);
+    if (options.filename) {
+        if (!options.filters && ((_a = options.miniProgram) === null || _a === void 0 ? void 0 : _a.filter)) {
+            options.filters = parseFilters(options.miniProgram.filter.lang, options.filename);
+        }
+    }
+    const context = (0, transform_1.transform)(ast, (0, shared_1.extend)({}, options, {
+        prefixIdentifiers,
+        nodeTransforms: [...nodeTransforms, ...(options.nodeTransforms || [])],
+        directiveTransforms: (0, shared_1.extend)({}, directiveTransforms, options.directiveTransforms || {}),
+    }));
+    const result = (0, shared_1.extend)((0, codegen_1.generate)((0, shared_1.extend)(ast, {
+        bindingComponents: context.bindingComponents,
+    }), options), { ast });
+    if (options.filename && ((_b = options.miniProgram) === null || _b === void 0 ? void 0 : _b.emitFile)) {
+        const { class: clazz, directive, emitFile, event, slot, lazyElement, component, } = options.miniProgram;
+        (0, codegen_2.generate)(ast, {
+            class: clazz,
+            scopeId: options.scopeId,
+            filename: options.filename,
+            directive,
+            emitFile,
+            event,
+            slot,
+            lazyElement,
+            component,
+            isBuiltInComponent: context.isBuiltInComponent,
+        });
+    }
+    return result;
+}
+exports.baseCompile = baseCompile;
+function genHashId(options) {
+    if (options.hashId) {
+        return options.hashId;
+    }
+    if (options.scopeId) {
+        return options.scopeId.replace('data-v-', '');
+    }
+    if (options.filename) {
+        return (0, uni_cli_shared_1.hash)(options.filename);
+    }
+    return '';
+}
+function parseFilters(lang, filename) {
+    filename = filename.split('?')[0];
+    if (fs_1.default.existsSync(filename)) {
+        return (0, uni_cli_shared_1.parseFilterNames)(lang, fs_1.default.readFileSync(filename, 'utf8'));
+    }
+    return [];
+}

package/dist/decodeHtml.d.ts

@@ -0,0 +1,2 @@
+import { ParserOptions } from '@vue/compiler-core';
+export declare const decodeHtml: ParserOptions['decodeEntities'];

package/dist/decodeHtml.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeHtml = void 0;
+const namedChars_json_1 = __importDefault(require("./namedChars.json"));
+// lazy compute this to make this file tree-shakable for browser
+let maxCRNameLength;
+const decodeHtml = (rawText, asAttr) => {
+    let offset = 0;
+    const end = rawText.length;
+    let decodedText = '';
+    function advance(length) {
+        offset += length;
+        rawText = rawText.slice(length);
+    }
+    while (offset < end) {
+        const head = /&(?:#x?)?/i.exec(rawText);
+        if (!head || offset + head.index >= end) {
+            const remaining = end - offset;
+            decodedText += rawText.slice(0, remaining);
+            advance(remaining);
+            break;
+        }
+        // Advance to the "&".
+        decodedText += rawText.slice(0, head.index);
+        advance(head.index);
+        if (head[0] === '&') {
+            // Named character reference.
+            let name = '';
+            let value = undefined;
+            if (/[0-9a-z]/i.test(rawText[1])) {
+                if (!maxCRNameLength) {
+                    maxCRNameLength = Object.keys(namedChars_json_1.default).reduce((max, name) => Math.max(max, name.length), 0);
+                }
+                for (let length = maxCRNameLength; !value && length > 0; --length) {
+                    name = rawText.substr(1, length);
+                    value = namedChars_json_1.default[name];
+                }
+                if (value) {
+                    const semi = name.endsWith(';');
+                    if (asAttr &&
+                        !semi &&
+                        /[=a-z0-9]/i.test(rawText[name.length + 1] || '')) {
+                        decodedText += '&' + name;
+                        advance(1 + name.length);
+                    }
+                    else {
+                        decodedText += value;
+                        advance(1 + name.length);
+                    }
+                }
+                else {
+                    decodedText += '&' + name;
+                    advance(1 + name.length);
+                }
+            }
+            else {
+                decodedText += '&';
+                advance(1);
+            }
+        }
+        else {
+            // Numeric character reference.
+            const hex = head[0] === '&#x';
+            const pattern = hex ? /^&#x([0-9a-f]+);?/i : /^&#([0-9]+);?/;
+            const body = pattern.exec(rawText);
+            if (!body) {
+                decodedText += head[0];
+                advance(head[0].length);
+            }
+            else {
+                // https://html.spec.whatwg.org/multipage/parsing.html#numeric-character-reference-end-state
+                let cp = Number.parseInt(body[1], hex ? 16 : 10);
+                if (cp === 0) {
+                    cp = 0xfffd;
+                }
+                else if (cp > 0x10ffff) {
+                    cp = 0xfffd;
+                }
+                else if (cp >= 0xd800 && cp <= 0xdfff) {
+                    cp = 0xfffd;
+                }
+                else if ((cp >= 0xfdd0 && cp <= 0xfdef) || (cp & 0xfffe) === 0xfffe) {
+                    // noop
+                }
+                else if ((cp >= 0x01 && cp <= 0x08) ||
+                    cp === 0x0b ||
+                    (cp >= 0x0d && cp <= 0x1f) ||
+                    (cp >= 0x7f && cp <= 0x9f)) {
+                    cp = CCR_REPLACEMENTS[cp] || cp;
+                }
+                decodedText += String.fromCodePoint(cp);
+                advance(body[0].length);
+            }
+        }
+    }
+    return decodedText;
+};
+exports.decodeHtml = decodeHtml;
+// https://html.spec.whatwg.org/multipage/parsing.html#numeric-character-reference-end-state
+const CCR_REPLACEMENTS = {
+    0x80: 0x20ac,
+    0x82: 0x201a,
+    0x83: 0x0192,
+    0x84: 0x201e,
+    0x85: 0x2026,
+    0x86: 0x2020,
+    0x87: 0x2021,
+    0x88: 0x02c6,
+    0x89: 0x2030,
+    0x8a: 0x0160,
+    0x8b: 0x2039,
+    0x8c: 0x0152,
+    0x8e: 0x017d,
+    0x91: 0x2018,
+    0x92: 0x2019,
+    0x93: 0x201c,
+    0x94: 0x201d,
+    0x95: 0x2022,
+    0x96: 0x2013,
+    0x97: 0x2014,
+    0x98: 0x02dc,
+    0x99: 0x2122,
+    0x9a: 0x0161,
+    0x9b: 0x203a,
+    0x9c: 0x0153,
+    0x9e: 0x017e,
+    0x9f: 0x0178,
+};

package/dist/errors.d.ts

@@ -0,0 +1,16 @@
+import { CompilerError, SourceLocation } from '@vue/compiler-core';
+export declare const enum MPErrorCodes {
+    X_V_ON_NO_ARGUMENT = 0,
+    X_V_ON_DYNAMIC_EVENT = 1,
+    X_V_BIND_NO_ARGUMENT = 2,
+    X_V_BIND_DYNAMIC_ARGUMENT = 3,
+    X_V_BIND_MODIFIER_PROP = 4,
+    X_V_BIND_MODIFIER_ATTR = 5,
+    X_V_IS_NOT_SUPPORTED = 6,
+    X_NOT_SUPPORTED = 7,
+    X_DYNAMIC_COMPONENT_NOT_SUPPORTED = 8
+}
+export interface MPCompilerError extends CompilerError {
+    code: MPErrorCodes;
+}
+export declare function createMPCompilerError(code: MPErrorCodes, loc?: SourceLocation, additionalMessage?: string): MPCompilerError;

package/dist/errors.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMPCompilerError = void 0;
+const compiler_core_1 = require("@vue/compiler-core");
+const MPErrorMessages = {
+    [0 /* X_V_ON_NO_ARGUMENT */]: 'v-on="" is not supported',
+    [1 /* X_V_ON_DYNAMIC_EVENT */]: 'v-on:[event]="" is not supported.',
+    [2 /* X_V_BIND_NO_ARGUMENT */]: 'v-bind="" is not supported.',
+    [3 /* X_V_BIND_DYNAMIC_ARGUMENT */]: 'v-bind:[name]="" is not supported.',
+    [4 /* X_V_BIND_MODIFIER_PROP */]: 'v-bind .prop is not supported',
+    [5 /* X_V_BIND_MODIFIER_ATTR */]: 'v-bind .attr is not supported',
+    [8 /* X_DYNAMIC_COMPONENT_NOT_SUPPORTED */]: '<component is=""/> is not supported',
+    [7 /* X_NOT_SUPPORTED */]: 'not supported: ',
+    [6 /* X_V_IS_NOT_SUPPORTED */]: 'v-is not supported',
+};
+function createMPCompilerError(code, loc, additionalMessage) {
+    return (0, compiler_core_1.createCompilerError)(code, loc, MPErrorMessages, additionalMessage);
+}
+exports.createMPCompilerError = createMPCompilerError;

package/dist/identifier.d.ts

@@ -0,0 +1,7 @@
+export default class IdentifierGenerator {
+    private _chars;
+    private _nextIds;
+    next(): string;
+    _increment(): void;
+    [Symbol.iterator](): Generator<string, void, unknown>;
+}

package/dist/identifier.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class IdentifierGenerator {
+    constructor() {
+        // u 被框架占用了，不提供 u 开头的变量名
+        this._chars = 'abcdefghijklmnopqrstvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        this._nextIds = [0];
+    }
+    next() {
+        const r = [];
+        for (const char of this._nextIds) {
+            r.unshift(this._chars[char]);
+        }
+        this._increment();
+        return r.join('');
+    }
+    _increment() {
+        for (let i = 0; i < this._nextIds.length; i++) {
+            const val = ++this._nextIds[i];
+            if (val >= this._chars.length) {
+                this._nextIds[i] = 0;
+            }
+            else {
+                return;
+            }
+        }
+        this._nextIds.push(0);
+    }
+    *[Symbol.iterator]() {
+        while (true) {
+            yield this.next();
+        }
+    }
+}
+exports.default = IdentifierGenerator;

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { CodegenResult, ParserOptions, RootNode } from '@vue/compiler-core';
+import { CompilerOptions } from './options';
+export { findProp } from '@vue/compiler-core';
+export type { CompilerOptions, DirectiveNode, NodeTransform, DirectiveTransform, TransformContext, SimpleExpressionNode, } from '@vue/compiler-core';
+export { genExpr } from './codegen';
+export { rewriteExpression } from './transforms/utils';
+export { isForElementNode } from './transforms/vFor';
+export { transformOn } from './transforms/vOn';
+export { transformModel } from './transforms/vModel';
+export * from './runtimeHelpers';
+export declare function parse(template: string, options?: ParserOptions): RootNode;
+export declare function compile(template: string, options?: CompilerOptions): CodegenResult;

package/dist/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compile = exports.parse = exports.transformModel = exports.transformOn = exports.isForElementNode = exports.rewriteExpression = exports.genExpr = exports.findProp = void 0;
+const shared_1 = require("@vue/shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const compile_1 = require("./compile");
+const parserOptions_1 = require("./parserOptions");
+var compiler_core_2 = require("@vue/compiler-core");
+Object.defineProperty(exports, "findProp", { enumerable: true, get: function () { return compiler_core_2.findProp; } });
+var codegen_1 = require("./codegen");
+Object.defineProperty(exports, "genExpr", { enumerable: true, get: function () { return codegen_1.genExpr; } });
+var utils_1 = require("./transforms/utils");
+Object.defineProperty(exports, "rewriteExpression", { enumerable: true, get: function () { return utils_1.rewriteExpression; } });
+var vFor_1 = require("./transforms/vFor");
+Object.defineProperty(exports, "isForElementNode", { enumerable: true, get: function () { return vFor_1.isForElementNode; } });
+var vOn_1 = require("./transforms/vOn");
+Object.defineProperty(exports, "transformOn", { enumerable: true, get: function () { return vOn_1.transformOn; } });
+var vModel_1 = require("./transforms/vModel");
+Object.defineProperty(exports, "transformModel", { enumerable: true, get: function () { return vModel_1.transformModel; } });
+__exportStar(require("./runtimeHelpers"), exports);
+function parse(template, options = {}) {
+    return (0, compiler_core_1.baseParse)(template, (0, shared_1.extend)({}, parserOptions_1.parserOptions, options));
+}
+exports.parse = parse;
+function compile(template, options = {}) {
+    return (0, compile_1.baseCompile)(template, (0, shared_1.extend)({}, parserOptions_1.parserOptions, options, {
+        directiveTransforms: (0, shared_1.extend)({}, options.directiveTransforms || {}),
+    }));
+}
+exports.compile = compile;