@dcloudio/uni-cli-shared 0.0.1-nvue3.3030820220125001

package/dist/vue/utils.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renameProp = exports.getBaseNodeTransforms = exports.createUniVueTransformAssetUrls = exports.createBindDirectiveNode = exports.createOnDirectiveNode = exports.createDirectiveNode = exports.addStaticClass = exports.createAttributeNode = exports.isUserComponent = exports.isVueSfcFile = exports.VUE_REF_IN_FOR = exports.VUE_REF = void 0;
+const shared_1 = require("@vue/shared");
+const uni_shared_1 = require("@dcloudio/uni-shared");
+const compiler_core_1 = require("@vue/compiler-core");
+const templateTransformAssetUrl_1 = require("./transforms/templateTransformAssetUrl");
+const templateTransformSrcset_1 = require("./transforms/templateTransformSrcset");
+const ast_1 = require("../vite/utils/ast");
+const url_1 = require("../vite/utils/url");
+const constants_1 = require("../constants");
+exports.VUE_REF = 'r';
+exports.VUE_REF_IN_FOR = 'r-i-f';
+function isVueSfcFile(id) {
+    const { filename, query } = (0, url_1.parseVueRequest)(id);
+    return constants_1.EXTNAME_VUE_RE.test(filename) && !query.vue;
+}
+exports.isVueSfcFile = isVueSfcFile;
+function isUserComponent(node, context) {
+    return (node.type === 1 /* ELEMENT */ &&
+        node.tagType === 1 /* COMPONENT */ &&
+        !(0, uni_shared_1.isComponentTag)(node.tag) &&
+        !(0, compiler_core_1.isCoreComponent)(node.tag) &&
+        !context.isBuiltInComponent(node.tag));
+}
+exports.isUserComponent = isUserComponent;
+function createAttributeNode(name, content) {
+    return {
+        type: 6 /* ATTRIBUTE */,
+        loc: compiler_core_1.locStub,
+        name,
+        value: {
+            type: 2 /* TEXT */,
+            loc: compiler_core_1.locStub,
+            content,
+        },
+    };
+}
+exports.createAttributeNode = createAttributeNode;
+function createClassAttribute(clazz) {
+    return createAttributeNode('class', clazz);
+}
+function addStaticClass(node, clazz) {
+    const classProp = node.props.find((prop) => prop.type === 6 /* ATTRIBUTE */ && prop.name === 'class');
+    if (!classProp) {
+        return node.props.unshift(createClassAttribute(clazz));
+    }
+    if (classProp.value) {
+        return (classProp.value.content = classProp.value.content + ' ' + clazz);
+    }
+    classProp.value = {
+        type: 2 /* TEXT */,
+        loc: compiler_core_1.locStub,
+        content: clazz,
+    };
+}
+exports.addStaticClass = addStaticClass;
+function createDirectiveNode(name, arg, exp) {
+    return {
+        type: 7 /* DIRECTIVE */,
+        name,
+        modifiers: [],
+        loc: compiler_core_1.locStub,
+        arg: (0, compiler_core_1.createSimpleExpression)(arg, true),
+        exp: (0, shared_1.isString)(exp) ? (0, compiler_core_1.createSimpleExpression)(exp, false) : exp,
+    };
+}
+exports.createDirectiveNode = createDirectiveNode;
+function createOnDirectiveNode(name, value) {
+    return createDirectiveNode('on', name, value);
+}
+exports.createOnDirectiveNode = createOnDirectiveNode;
+function createBindDirectiveNode(name, value) {
+    return createDirectiveNode('bind', name, value);
+}
+exports.createBindDirectiveNode = createBindDirectiveNode;
+function createUniVueTransformAssetUrls(base) {
+    return {
+        base,
+        includeAbsolute: true,
+        tags: {
+            audio: ['src'],
+            video: ['src', 'poster'],
+            img: ['src'],
+            image: ['src'],
+            'cover-image': ['src'],
+            // h5
+            'v-uni-audio': ['src'],
+            'v-uni-video': ['src', 'poster'],
+            'v-uni-image': ['src'],
+            'v-uni-cover-image': ['src'],
+            // nvue
+            'u-image': ['src'],
+            'u-video': ['src', 'poster'],
+        },
+    };
+}
+exports.createUniVueTransformAssetUrls = createUniVueTransformAssetUrls;
+function getBaseNodeTransforms(base) {
+    const transformAssetUrls = createUniVueTransformAssetUrls(base);
+    return [
+        (0, templateTransformAssetUrl_1.createAssetUrlTransformWithOptions)(transformAssetUrls),
+        (0, templateTransformSrcset_1.createSrcsetTransformWithOptions)(transformAssetUrls),
+    ];
+}
+exports.getBaseNodeTransforms = getBaseNodeTransforms;
+function renameProp(name, prop) {
+    if (!prop) {
+        return;
+    }
+    if ((0, ast_1.isDirectiveNode)(prop)) {
+        if (prop.arg && (0, compiler_core_1.isStaticExp)(prop.arg)) {
+            prop.arg.content = name;
+        }
+    }
+    else {
+        prop.name = name;
+    }
+}
+exports.renameProp = renameProp;

package/dist/watcher.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import { FSWatcher, WatchOptions } from 'chokidar';
+declare type FileTransform = (source: Buffer, filename: string) => void | string;
+export interface FileWatcherOptions {
+    src: string | string[];
+    dest: string;
+    transform?: FileTransform;
+    verbose?: boolean;
+}
+export declare class FileWatcher {
+    private src;
+    private dest;
+    private transform?;
+    private verbose?;
+    private watcher;
+    private onChange?;
+    constructor({ src, dest, transform, verbose }: FileWatcherOptions);
+    watch(watchOptions: WatchOptions & {
+        cwd: string;
+    }, onReady?: (watcher: FSWatcher) => void, onChange?: () => void): FSWatcher;
+    add(paths: string | ReadonlyArray<string>): void;
+    unwatch(paths: string | ReadonlyArray<string>): void;
+    close(): Promise<void>;
+    copy(from: string): Promise<void | undefined>;
+    remove(from: string): Promise<void | undefined>;
+    info(type: 'close' | 'copy' | 'remove' | 'add' | 'unwatch', msg?: string | unknown): void;
+    from(from: string): string;
+    to(from: string): string;
+}
+export {};

package/dist/watcher.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileWatcher = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chokidar_1 = require("chokidar");
+class FileWatcher {
+    constructor({ src, dest, transform, verbose }) {
+        this.src = !Array.isArray(src) ? [src] : src;
+        this.dest = dest;
+        this.transform = transform;
+        this.verbose = verbose;
+    }
+    watch(watchOptions, onReady, onChange) {
+        if (!this.watcher) {
+            const copy = this.copy.bind(this);
+            const remove = this.remove.bind(this);
+            this.watcher = (0, chokidar_1.watch)(this.src, watchOptions)
+                .on('add', copy)
+                .on('addDir', copy)
+                .on('change', copy)
+                .on('unlink', remove)
+                .on('unlinkDir', remove)
+                .on('ready', () => {
+                onReady && onReady(this.watcher);
+                setTimeout(() => {
+                    this.onChange = onChange;
+                }, 1000);
+            })
+                .on('error', (e) => console.error('watch', e));
+        }
+        return this.watcher;
+    }
+    add(paths) {
+        this.info('add', paths);
+        return this.watcher.add(paths);
+    }
+    unwatch(paths) {
+        this.info('unwatch', paths);
+        return this.watcher.unwatch(paths);
+    }
+    close() {
+        this.info('close');
+        return this.watcher.close();
+    }
+    copy(from) {
+        const to = this.to(from);
+        this.info('copy', from + '=>' + to);
+        let content;
+        if (this.transform) {
+            const filename = this.from(from);
+            content = this.transform(fs_extra_1.default.readFileSync(filename), filename);
+        }
+        if (content) {
+            return fs_extra_1.default
+                .outputFile(to, content)
+                .catch(() => {
+                // this.info('copy', e)
+            })
+                .then(() => this.onChange && this.onChange());
+        }
+        return fs_extra_1.default
+            .copy(this.from(from), to, { overwrite: true })
+            .catch(() => {
+            // this.info('copy', e)
+        })
+            .then(() => this.onChange && this.onChange());
+    }
+    remove(from) {
+        const to = this.to(from);
+        this.info('remove', from + '=>' + to);
+        return fs_extra_1.default
+            .remove(to)
+            .catch(() => {
+            // this.info('remove', e)
+        })
+            .then(() => this.onChange && this.onChange());
+    }
+    info(type, msg) {
+        this.verbose && console.log(type, msg);
+    }
+    from(from) {
+        return path_1.default.join(this.watcher.options.cwd, from);
+    }
+    to(from) {
+        return path_1.default.join(this.dest, from);
+    }
+}
+exports.FileWatcher = FileWatcher;

package/lib/crypto.js

@@ -0,0 +1,65 @@
+var lookup = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 62, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+  0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
+  21, 22, 23, 24, 25, 0, 0, 0, 0, 63, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+  40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
+]
+
+function base64Decode (source, target) {
+  var sourceLength = source.length
+  var paddingLength = (source[sourceLength - 2] === '=' ? 2 : (source[sourceLength - 1] === '=' ? 1
+    : 0))
+
+  var tmp
+  var byteIndex = 0
+  var baseLength = (sourceLength - paddingLength) & 0xfffffffc
+
+  for (var i = 0; i < baseLength; i += 4) {
+    tmp = (lookup[source.charCodeAt(i)] << 18) |
+      (lookup[source.charCodeAt(i + 1)] << 12) |
+      (lookup[source.charCodeAt(i + 2)] << 6) |
+      (lookup[source.charCodeAt(i + 3)])
+
+    target[byteIndex++] = (tmp >> 16) & 0xFF
+    target[byteIndex++] = (tmp >> 8) & 0xFF
+    target[byteIndex++] = (tmp) & 0xFF
+  }
+
+  if (paddingLength === 1) {
+    tmp = (lookup[source.charCodeAt(i)] << 10) |
+      (lookup[source.charCodeAt(i + 1)] << 4) |
+      (lookup[source.charCodeAt(i + 2)] >> 2)
+
+    target[byteIndex++] = (tmp >> 8) & 0xFF
+    target[byteIndex++] = tmp & 0xFF
+  }
+
+  if (paddingLength === 2) {
+    tmp = (lookup[source.charCodeAt(i)] << 2) | (lookup[source.charCodeAt(i + 1)] >> 4)
+
+    target[byteIndex++] = tmp & 0xFF
+  }
+}
+
+export default {
+  getRandomValues (arr) {
+    if (!(
+      arr instanceof Int8Array ||
+        arr instanceof Uint8Array ||
+        arr instanceof Int16Array ||
+        arr instanceof Uint16Array ||
+        arr instanceof Int32Array ||
+        arr instanceof Uint32Array ||
+        arr instanceof Uint8ClampedArray
+    )) {
+      throw new Error('Expected an integer array')
+    }
+    if (arr.byteLength > 65536) {
+      throw new Error('Can only request a maximum of 65536 bytes')
+    }
+    var crypto = uni.requireNativePlugin('DCloud-Crypto')
+    base64Decode(crypto.getRandomValues(arr.byteLength), new Uint8Array(arr.buffer, arr.byteOffset,
+      arr.byteLength))
+    return arr
+  }
+}

package/lib/nvue.css

@@ -0,0 +1,34 @@
+label,
+scroll-view,
+swiper-item,
+view {
+  display: flex;
+  flex-direction: column;
+  flex-shrink: 0;
+  flex-grow: 0;
+  flex-basis: auto;
+  align-items: stretch;
+  align-content: flex-start;
+}
+
+image,
+input,
+scroll-view,
+swiper,
+swiper-item,
+text,
+textarea,
+video,
+view {
+  position: relative;
+  border: 0 solid #000;
+  box-sizing: border-box;
+}
+
+swiper-item {
+  position: absolute;
+}
+
+button {
+  margin: 0;
+}

package/lib/preprocess/LICENSE

@@ -0,0 +1,13 @@
+ Copyright 2012 OneHealth Solutions, Inc
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.