@baic/yolk-cli 2.1.0-alpha.9 → 2.1.0-github.0

package/templates/umi-mobile-native/package.json.tpl

@@ -0,0 +1,16 @@
+{
+  "private": true,
+  "name": "{{ projectName }}",
+  "scripts": {
+    "start": "yolk start",
+    "build": "yolk build"
+  },
+  "dependencies": {
+    "@baic/preset-yolk-umi-mobile": "~{{ yolkVersion }}"
+  },
+  "pnpm": {
+    "peerDependencyRules": {
+      "ignoreMissing": "*"
+    }
+  }
+}

package/templates/umi-mobile-native/src/app.tsx

@@ -0,0 +1,19 @@
+import { Provider } from '@baic/yolk-mobile';
+
+import request from '@/common/request';
+
+import '@baic/yolk-mobile/es/style/index.less';
+
+export function rootContainer(container: React.ReactNode) {
+  return (
+    <Provider
+      request={request}
+      iconfontScriptUrl={[
+        '//at.alicdn.com/t/font_1788044_0dwu4guekcwr.js',
+        '//at.alicdn.com/t/font_1788592_a5xf2bdic3u.js',
+      ]}
+    >
+      {container}
+    </Provider>
+  );
+}

package/templates/umi-mobile-native/src/common/Xprinter.ts

@@ -0,0 +1,58 @@
+import bridge from './bridge';
+
+interface Options {
+  deviceId?: string;
+  commands?: PrintCommand[];
+}
+type FunctionName = 'connect' | 'disconnect' | 'print' | 'getBondedDevices';
+
+export type PrintCommand = Record<
+  string,
+  string | number | (string | number)[]
+> & {
+  command:
+    | 'sizeBymm'
+    | 'gapBymm'
+    | 'cls'
+    | 'direction'
+    | 'bar'
+    | 'barCode'
+    | 'qrCode'
+    | 'text'
+    | 'bitmap'
+    | 'print';
+  args?: (string | number)[];
+  url?: string;
+};
+
+export interface BondedDevice {
+  name: string;
+  deviceId: string;
+  bondState: number;
+  type: number;
+  alias?: string;
+}
+
+const Xprinter = {
+  exec<T = object>(functionName: FunctionName, options?: Options) {
+    return bridge.exec<T>('Xprinter', functionName, options);
+  },
+  disconnect() {
+    return Xprinter.exec('disconnect');
+  },
+  async connect(deviceId?: string | null) {
+    await Xprinter.disconnect();
+    if (deviceId) {
+      return Xprinter.exec('connect', { deviceId });
+    }
+    throw Error('连接失败');
+  },
+  print(commands: PrintCommand[]) {
+    return Xprinter.exec('print', { commands });
+  },
+  getBondedDevices() {
+    return Xprinter.exec<BondedDevice[]>('getBondedDevices');
+  },
+};
+
+export default Xprinter;

package/templates/umi-mobile-native/src/common/bluetooth.ts

@@ -0,0 +1,354 @@
+import _ from 'lodash';
+
+import { Toast } from 'antd-mobile';
+
+import Util from '@/common/util';
+
+export interface BluetoothOptions {
+  autoReconnection?: boolean;
+  onWriteValue?: () => ArrayBuffer;
+  writeInterval?: number;
+  readInterval?: number;
+  reconnectInterval?: number;
+  notifyInterval?: number;
+}
+
+class Bluetooth {
+  private options: BluetoothOptions = {
+    autoReconnection: true,
+    writeInterval: 300,
+    readInterval: 300,
+    reconnectInterval: 1000,
+    notifyInterval: 200,
+  };
+
+  private devices: plus.Bluetooth.BluetoothDeviceInfo[] = [];
+
+  // private connectedDeviceId: string = '';
+
+  private listenServicesTimeoutId?: NodeJS.Timeout;
+
+  private writeTimeoutId?: NodeJS.Timeout;
+
+  private readTimeoutId?: NodeJS.Timeout;
+
+  private isNotifyInterval?: boolean;
+
+  constructor(options?: BluetoothOptions) {
+    this.options = {
+      ...this.options,
+      ...options,
+    };
+  }
+
+  public isAvailableAdapter = () => {
+    const { bluetooth } = window.plus || {};
+    return new Promise<boolean>((resolve, reject) => {
+      bluetooth.getBluetoothAdapterState({
+        success: ({ available, discovering }) => {
+          if (available) {
+            resolve(discovering);
+          } else {
+            reject();
+          }
+        },
+        fail: reject,
+      });
+    });
+  };
+
+  private openBluetoothAdapter() {
+    const { bluetooth } = window.plus || {};
+    return new Promise<void>((resolve, reject) => {
+      bluetooth.openBluetoothAdapter({
+        success: resolve,
+        fail: reject,
+      });
+    });
+  }
+
+  public async init() {
+    try {
+      await this.openBluetoothAdapter();
+    } catch (error) {
+      Toast.show({
+        icon: 'fail',
+        content: '蓝牙不可用，请检查蓝牙设置',
+      });
+      return Promise.reject(error);
+    }
+    return Promise.resolve();
+  }
+
+  public setConnectionStateChangeListener(
+    e: plus.Bluetooth.BLEConnectionStateChangeCallback,
+  ) {
+    const { bluetooth } = window.plus || {};
+    const { autoReconnection, reconnectInterval = 1000 } = this.options;
+    bluetooth.onBLEConnectionStateChange(async ({ connected, deviceId }) => {
+      if (connected) {
+        Toast.clear();
+        this.startListenConnectedDevice(deviceId);
+      } else if (autoReconnection) {
+        await this.destroy();
+        const reconnect = async () => {
+          try {
+            await this.openBluetoothAdapter();
+            await this.connect({ deviceId });
+          } catch (error) {
+            setTimeout(reconnect, reconnectInterval);
+          }
+        };
+        Toast.show({
+          icon: 'loading',
+          content: '蓝牙设备重连',
+          duration: 0,
+        });
+        reconnect();
+      } else {
+        this.destroy();
+        Toast.show({
+          icon: 'fail',
+          content: '蓝牙设备断开',
+        });
+      }
+      if (_.isFunction(e)) {
+        e({ connected, deviceId });
+      }
+    });
+  }
+
+  public setDeviceFoundListener(
+    e: plus.Bluetooth.BluetoothDeviceFoundCallback,
+  ) {
+    const { bluetooth } = window.plus || {};
+    bluetooth.onBluetoothDeviceFound(({ devices = [] }) => {
+      this.devices = _.unionBy(
+        this.devices.concat(
+          devices.filter(
+            ({ name }: plus.Bluetooth.BluetoothDeviceInfo) =>
+              !Util.isEmpty(name),
+          ),
+        ),
+        'deviceId',
+      );
+      if (_.isFunction(e)) {
+        e({ devices: this.devices });
+      }
+    });
+  }
+
+  public setValueChangeListener = (onChange: (e: ArrayBuffer) => void) => {
+    const { bluetooth } = window.plus || {};
+    const { notifyInterval = 200 } = this.options;
+    bluetooth.onBLECharacteristicValueChange(({ value }) => {
+      if (_.isFunction(onChange)) {
+        if (notifyInterval > 0) {
+          if (!this.isNotifyInterval) {
+            onChange(value);
+            this.isNotifyInterval = true;
+            setTimeout(() => {
+              this.isNotifyInterval = false;
+            }, notifyInterval);
+          }
+        } else {
+          onChange(value);
+        }
+      }
+    });
+  };
+
+  public async startSearchDevices() {
+    const { bluetooth } = window.plus || {};
+    const discovering = await this.isAvailableAdapter();
+    return new Promise<void>((resolve, reject) => {
+      if (!discovering) {
+        this.devices = [];
+        bluetooth.startBluetoothDevicesDiscovery({
+          interval: 0,
+          success: resolve,
+          fail: reject,
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  public async stopSearchDevices() {
+    const { bluetooth } = window.plus || {};
+    const discovering = await this.isAvailableAdapter();
+    return new Promise<void>((resolve, reject) => {
+      if (discovering) {
+        bluetooth.stopBluetoothDevicesDiscovery({
+          success: () => {
+            this.devices = [];
+            resolve();
+          },
+          fail: reject,
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  public async connect({ deviceId }: plus.Bluetooth.BluetoothDeviceInfo) {
+    const { bluetooth } = window.plus || {};
+    await this.isAvailableAdapter();
+    await this.stopSearchDevices();
+    return new Promise<void>((resolve, reject) => {
+      if (deviceId) {
+        bluetooth.createBLEConnection({
+          deviceId,
+          success: resolve,
+          fail: reject,
+        });
+      } else {
+        reject('连接失败');
+      }
+    });
+  }
+
+  private async write(
+    deviceId: string,
+    serviceId: string,
+    characteristicId: string,
+  ) {
+    const { bluetooth } = window.plus || {};
+    const { onWriteValue, writeInterval = 300 } = this.options;
+    await this.isAvailableAdapter();
+    bluetooth.writeBLECharacteristicValue({
+      deviceId,
+      serviceId,
+      characteristicId,
+      value: _.isFunction(onWriteValue) ? onWriteValue() : new ArrayBuffer(0),
+    });
+    if (writeInterval > 0) {
+      this.writeTimeoutId = setTimeout(
+        () => this.write(deviceId, serviceId, characteristicId),
+        writeInterval,
+      );
+    }
+  }
+
+  private async read(
+    deviceId: string,
+    serviceId: string,
+    characteristicId: string,
+  ) {
+    const { bluetooth } = window.plus || {};
+    const { readInterval = 300 } = this.options;
+    await this.isAvailableAdapter();
+    bluetooth.readBLECharacteristicValue({
+      deviceId,
+      serviceId,
+      characteristicId,
+    });
+    if (readInterval > 0) {
+      this.readTimeoutId = setTimeout(
+        () => this.read(deviceId, serviceId, characteristicId),
+        readInterval,
+      );
+    }
+  }
+
+  private async startListenConnectedDevice(deviceId: string) {
+    const { bluetooth } = window.plus || {};
+    await this.isAvailableAdapter();
+    if (deviceId) {
+      return new Promise<void>((resolve, reject) => {
+        const fn = () => {
+          bluetooth.getBLEDeviceServices({
+            deviceId,
+            success: ({ services = [] }) => {
+              if (services.length) {
+                services.forEach(({ uuid: serviceId = '', isPrimary }) => {
+                  if (isPrimary) {
+                    bluetooth.getBLEDeviceCharacteristics({
+                      deviceId,
+                      serviceId,
+                      success: ({ characteristics = [] }) => {
+                        characteristics.forEach(
+                          ({ uuid: characteristicId = '', properties }) => {
+                            const { notify, write, read } = properties || {};
+                            if (notify) {
+                              bluetooth.notifyBLECharacteristicValueChange({
+                                deviceId,
+                                serviceId,
+                                characteristicId,
+                                state: true,
+                                success: () => {
+                                  if (write) {
+                                    this.write(
+                                      deviceId,
+                                      serviceId,
+                                      characteristicId,
+                                    );
+                                  }
+                                  if (read) {
+                                    this.read(
+                                      deviceId,
+                                      serviceId,
+                                      characteristicId,
+                                    );
+                                  }
+                                  resolve();
+                                },
+                                fail: reject,
+                              });
+                            }
+                          },
+                        );
+                      },
+                      fail: reject,
+                    });
+                  }
+                });
+              } else {
+                this.listenServicesTimeoutId = setTimeout(fn, 1000);
+              }
+            },
+            fail: reject,
+          });
+        };
+        fn();
+      });
+    }
+    return Promise.reject('没有连接蓝牙设备');
+  }
+
+  public async destroy() {
+    const { bluetooth } = window.plus || {};
+    if (this.listenServicesTimeoutId) {
+      clearTimeout(this.listenServicesTimeoutId);
+      this.listenServicesTimeoutId = undefined;
+    }
+    if (this.writeTimeoutId) {
+      clearTimeout(this.writeTimeoutId);
+      this.writeTimeoutId = undefined;
+    }
+    if (this.readTimeoutId) {
+      clearTimeout(this.readTimeoutId);
+      this.readTimeoutId = undefined;
+    }
+    try {
+      const discovering = await this.isAvailableAdapter();
+      if (discovering) {
+        await this.stopSearchDevices();
+      }
+      return await new Promise<void>((resolve, reject) => {
+        this.devices = [];
+        bluetooth.closeBluetoothAdapter({
+          success: resolve,
+          fail: reject,
+        });
+      });
+    } catch (error) {
+      console.error(error);
+    }
+    return Promise.resolve();
+  }
+}
+
+export default Bluetooth;

package/templates/umi-mobile-native/src/common/bridge.ts

@@ -0,0 +1,59 @@
+import _ from 'lodash';
+
+type Result<T = object> = {
+  code: number;
+  message?: string;
+  data?: T;
+};
+
+const bridge = {
+  exec<T = object, Options = object>(
+    pluginName: string,
+    functionName: string,
+    options?: Options,
+    success?: (data?: T) => void,
+    complete?: (event?: Result<T>) => void,
+    fail?: (event?: Result<T>) => void,
+  ) {
+    return new Promise<T | undefined>((resolve, reject) => {
+      const successCallback = (event: Result<T>) => {
+        if (_.isFunction(complete)) {
+          complete(event);
+        }
+        if (event) {
+          const { code, data } = event;
+          if (0 === code) {
+            if (_.isFunction(success)) {
+              success(data);
+            }
+            resolve(data);
+          } else {
+            if (_.isFunction(fail)) {
+              fail(event);
+            }
+            reject(event);
+          }
+        } else {
+          if (_.isFunction(fail)) {
+            fail({
+              code: -1,
+            });
+          }
+          reject({
+            code: -1,
+          });
+        }
+      };
+      const failCallback = (event?: Result<T>) => {
+        if (_.isFunction(fail)) {
+          fail(event);
+        }
+        reject(event);
+      };
+      const callbackId = plus.bridge.callbackId(successCallback, failCallback);
+      plus.bridge.exec(pluginName, functionName, [callbackId, options]);
+    });
+  },
+};
+
+export default bridge;

package/templates/umi-mobile-native/src/common/request.ts

@@ -0,0 +1,3 @@
+import { Request } from '@baic/yolk-mobile';
+
+export default new Request();

package/templates/umi-mobile-native/src/common/util.ts

@@ -0,0 +1,7 @@
+import { Util } from '@baic/yolk-mobile';
+
+const util = {
+  ...Util,
+};
+
+export default util;

package/templates/umi-mobile-native/src/global.less

@@ -0,0 +1,3 @@
+#yolk-app {
+  height: 100%;
+}

package/templates/umi-mobile-native/src/layouts/index.tsx

@@ -0,0 +1,3 @@
+import { Outlet } from 'umi';
+
+export default () => <Outlet />;

package/templates/umi-mobile-native/src/pages/404.tsx

@@ -0,0 +1,10 @@
+import * as React from 'react';
+import { Result } from 'antd-mobile';
+
+export default () => (
+  <Result
+    title="404"
+    description="对不起，您访问的页面不存在。"
+    status="warning"
+  />
+);

package/templates/umi-mobile-native/src/pages/demo/examples/BarCode.tsx

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import { BarCode } from '@baic/yolk-mobile';
+
+export default () => <BarCode value="https://www.baidu.com" />;

package/templates/umi-mobile-native/src/pages/demo/examples/Iconfont.tsx

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { Provider, Iconfont } from '@baic/yolk-mobile';
+
+export default () => {
+  return (
+    <Provider
+      iconfontScriptUrl={[
+        '//at.alicdn.com/t/font_1788044_0dwu4guekcwr.js',
+        '//at.alicdn.com/t/font_1788592_a5xf2bdic3u.js',
+      ]}
+    >
+      <Iconfont type="icon-javascript" />
+      <Iconfont type="icon-java" />
+      <Iconfont type="icon-shoppingcart" />
+      <Iconfont type="icon-python" />
+    </Provider>
+  );
+};

package/templates/umi-mobile-native/src/pages/demo/examples/Input.tsx

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { Form, Input, useForm } from '@baic/yolk-mobile';
+
+export default () => {
+  const [form] = useForm();
+  const { createFormItem } = form;
+  return (
+    <Form form={form}>
+      {createFormItem({
+        label: 'Input',
+        name: 'Input',
+        rules: 'required',
+      })(<Input maxLength={5} />)}
+    </Form>
+  );
+};

package/templates/umi-mobile-native/src/pages/demo/examples/List/1.tsx

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { List } from '@baic/yolk-mobile';
+
+export default () => {
+  return (
+    <List header='基础用法'>
+      <List.Item>1</List.Item>
+      <List.Item>2</List.Item>
+      <List.Item>3</List.Item>
+    </List>
+  );
+};

package/templates/umi-mobile-native/src/pages/demo/examples/List/2.tsx

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import { Image } from 'antd-mobile';
+import { List } from '@baic/yolk-mobile';
+
+import mock from './mock';
+
+export default () => {
+  return (
+    <List header="函数渲染" data={mock}>
+      {({ name, avatar, description }) => (
+        <List.Item
+          key={name}
+          prefix={
+            <Image
+              src={avatar}
+              style={{ borderRadius: 20 }}
+              fit="cover"
+              width={40}
+              height={40}
+            />
+          }
+          description={description}
+        >
+          {name}
+        </List.Item>
+      )}
+    </List>
+  );
+};

package/templates/umi-mobile-native/src/pages/demo/examples/List/3.tsx

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import { Image } from 'antd-mobile';
+import { List } from '@baic/yolk-mobile';
+
+import mock from './mock';
+
+export default () => {
+  return (
+    <List header="拖拽" drag data={mock}>
+      {({ name, avatar, description }) => (
+        <List.Item
+          key={name}
+          prefix={
+            <Image
+              src={avatar}
+              style={{ borderRadius: 20 }}
+              fit="cover"
+              width={40}
+              height={40}
+            />
+          }
+          description={description}
+        >
+          {name}
+        </List.Item>
+      )}
+    </List>
+  );
+};