swop-store - npm Package Compare versions

Comparing version 1.0.0 to 1.0.1

build/index.js

@@ -5,2 +5,1 @@ export * from './swop';
 export * from './static_store';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxnQkFBZ0IsQ0FBQyJ9

build/queue.js

@@ -46,2 +46,1 @@ export class Queue {
 }
-//# sourceMappingURL=data:application/json;base64,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

build/static_store.d.ts

@@ -0,1 +1,2 @@
+import { Swop } from './swop';
 import { Tool } from './tool';
@@ -6,4 +7,4 @@ export declare type MonitorFun = (new_value: any, old_value: any) => void;
 }
-export declare type StaticData<R> = {
-    [P in keyof R]: ContainerDataTypes;
+export declare type StaticData<I, R> = {
+    [P in keyof R]: ContainerDataTypes<I, keyof R>;
 };
@@ -13,6 +14,7 @@ export interface ContainerDataBaseTypes {
 }
-export interface ContainerDataTypes extends ContainerDataBaseTypes {
+export interface ContainerDataTypes<I, D> extends ContainerDataBaseTypes {
     subscribe: (monitor_fun: MonitorFun, once?: boolean) => () => void;
-    remove_all_sub: () => ContainerDataTypes;
-    set: (value: any) => ContainerDataTypes;
+    remove_all_sub: () => ContainerDataTypes<I, D>;
+    polling(interface_name?: I | D, call_data?: any, hook_fun?: any): () => void;
+    set: (value: any) => ContainerDataTypes<I, D>;
 }
@@ -22,16 +24,19 @@ export interface DataContainerClass<I, R, D> extends Tool {
     get_container_context(): Tool;
-    create(name: D, init_value?: any, read_only?: boolean): DataContainer<I, R, D>;
+    create(name: D, init_value?: any, read_only?: boolean): Swop<I, R>;
     get_all_data(): DataValue;
+    clear_polling(name?: keyof R): Swop<I, R>;
 }
 export declare class DataContainer<I, R, D> extends Tool implements DataContainerClass<I, R, D> {
-    types: StaticData<R>;
+    types: StaticData<I, R>;
     private states;
     private observer;
+    private polling_clump;
     private publish_observer(monitor_uint_arr, new_value, old_value);
     private define_subscribe_data(name, init_value, read_only);
     private create_static_data(name, init_value, read_only);
-    get_container_context(): DataContainer<I, R, D>;
     init(): void;
+    get_container_context(): Tool;
     get_all_data(): DataValue;
-    create(name: D, init_value?: any, read_only?: boolean): DataContainer<I, R, D>;
+    create(name: D, init_value?: any, read_only?: boolean): Swop<I, R>;
+    clear_polling(name?: keyof R): Swop<I, R>;
 }

build/static_store.js

@@ -73,2 +73,18 @@ import { Tool } from './tool';
             },
+            polling(interface_name, call_data, hook_fun) {
+                !interface_name && (interface_name = name);
+                let is_can_polling = true;
+                function start_polling(context) {
+                    self.call(interface_name, call_data).then(([data, opts]) => {
+                        hook_fun && hook_fun(data);
+                        context.set(data);
+                        opts.next();
+                        is_can_polling && start_polling(context);
+                    });
+                }
+                start_polling(this);
+                const clear = () => is_can_polling = false;
+                self.polling_clump[name] = clear;
+                return clear;
+            },
             set(value) {
@@ -88,2 +104,8 @@ const new_value = {
     }
+    init() {
+        this.states = {};
+        this.observer = {};
+        this.polling_clump = {};
+        this.types = this;
+    }
     get_container_context() {
@@ -96,7 +118,2 @@ let context = this;
     }
-    init() {
-        this.states = {};
-        this.observer = {};
-        this.types = this;
-    }
     get_all_data() {
@@ -109,3 +126,15 @@ return this.states;
     }
+    clear_polling(name) {
+        if (name) {
+            this.polling_clump[name]();
+            return this;
+        }
+        const names = Object.keys(this.polling_clump);
+        const length = names.length;
+        let i = 0;
+        for (; i < length; i++) {
+            this.polling_clump[names[i]]();
+        }
+        return this;
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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

build/swop.d.ts

 import { DataContainer } from './static_store';
 import { QueueTypes, UnitFun } from './queue';
-export declare type storeFunBody = (nextSwopFun: storeFunBody, next: UnitFun<any>, data: any, ...params: any[]) => void;
+export declare type Store<I> = {
+    [S in keyof I]: SingleStroeQueue;
+};
+export declare type storeFunBody = (next: UnitFun<any>, nextSwopFun: storeFunBody, data: any, ...params: any[]) => void;
 export interface FunUnit {
@@ -9,4 +12,4 @@ fun_body: storeFunBody;
 export interface SwopInitParam {
-    stringify_json?: boolean;
-    parse_json?: boolean;
+    json_stringify?: boolean;
+    json_parse?: boolean;
 }
@@ -35,8 +38,8 @@ export declare type MiddlewareAcceptValue<I, D> = {
 export declare class Swop<I, R, D = keyof R> extends DataContainer<I, R, D> implements SwopTypes<I, R, D> {
-    readonly stringify_json: boolean;
-    readonly parse_json: boolean;
-    private store;
+    readonly json_stringify: boolean;
+    readonly json_parse: boolean;
+    store: Store<I> | any;
     private middleware;
     send: send<I>;
-    constructor({stringify_json, parse_json}?: SwopInitParam);
+    constructor({json_stringify, json_parse}?: SwopInitParam);
     private call_middleware(match, params);
@@ -46,2 +49,4 @@ private create_callback(name, resolve);
     private get_name_by_id(id);
+    private get_id(data);
+    private get_json_origin_data(data);
     private send_request(name, data, reject);
@@ -54,2 +59,2 @@ use(match: I | D | '*', fun: Middleware<I, D>): Swop<I, R>;
 }
-export declare function CreateSwop<M>(...args: any[]): M;
+export declare function CreateSwop<M>(opions: SwopInitParam): M;

build/swop.js

@@ -0,13 +1,15 @@
+import { warn } from './tool';
 import { DataContainer } from './static_store';
 import { Queue } from './queue';
 const DELIMITER = '_:_';
+const ID_REG = new RegExp(`,?"id":"[^}]+${DELIMITER}.+_:_swopid",?`, 'g');
 export class Swop extends DataContainer {
-    constructor({ stringify_json = false, parse_json = false, } = {}) {
+    constructor({ json_stringify = false, json_parse = false, } = {}) {
         super();
         this.store = {};
         this.middleware = [];
-        this.stringify_json = stringify_json;
-        this.parse_json = parse_json;
+        this.json_stringify = json_stringify;
+        this.json_parse = json_parse;
         this.send = () => {
-            console.warn('You must override the 【send】 method --- from Swop.js.');
+            warn('You must override the 【send】 method', true);
         };
@@ -28,5 +30,5 @@ this.init();
     create_callback(name, resolve) {
-        return (nextSwopFun, next, data, ...params) => {
+        return (next, nextSwopFun, data, ...params) => {
             const response_data = [
-                data.origin_data,
+                this.get_json_origin_data(data),
                 {
@@ -47,3 +49,3 @@ next,
         if (typeof id !== 'string' || (id && !id.includes(name))) {
-            throw Error(`【${id}】is Invalid id  ---  from Swop.js.`);
+            warn(`【${id}】is invalid id`);
         }
@@ -60,4 +62,31 @@ const list = this.store[name].funs || [];
     }
+    get_id(data) {
+        if (typeof data === 'string') {
+            if (!data.includes('origin_data' || !data.includes('swopid'))) {
+                warn('The response data must contain 【origin_data】 and 【id】');
+            }
+            const ID_GROUP_REG = new RegExp(`(,?"id":")([^}]+${DELIMITER}.+_:_swopid)"(,?)`, 'g');
+            const match = ID_GROUP_REG.exec(data);
+            if (!match || (match && !match[2])) {
+                warn(`Invalid id`);
+            }
+            return match[2];
+        }
+        return data.id;
+    }
+    get_json_origin_data(data) {
+        if (typeof data === 'string') {
+            data = data.replace(ID_REG, '');
+            const match = /({?"origin_data":)(.+)}(,.*)!?/g.exec(data);
+            if (!match) {
+                return data.replace(/({?"origin_data":)(.+)}/g, (k1, k2, k3) => k3);
+            }
+            return match[2];
+        }
+        return data.origin_data;
+    }
     send_request(name, data, reject) {
-        const stringify_data = this.convert_json(data, 'stringify', reject);
+        const stringify_data = this.json_stringify
+            ? this.convert_json(data, 'stringify', reject)
+            : data;
         this.send(name, stringify_data, data);
@@ -98,5 +127,12 @@ }
         return new Promise((resolve, reject) => {
-            const { store, convert_json } = this;
-            data = convert_json(data, 'parse', reject);
-            const name = this.get_name_by_id(data.id);
+            const { store, convert_json, json_parse } = this;
+            if (typeof data !== 'string' &&
+                (typeof data !== 'object' || data === null)) {
+                warn(`response data must be JSON string or javascript object`);
+            }
+            if (json_parse) {
+                data = convert_json(data, 'parse', reject);
+            }
+            const id = this.get_id(data);
+            const name = this.get_name_by_id(id);
             const { funs, queue } = store[name];
@@ -107,10 +143,11 @@ if (store[name]) {
                         fun_body() {
-                            console.warn('next Swop function is 【undefined】 ---  from Swop.js.');
+                            warn('next Swop function is 【undefined】', true);
                             return false;
                         },
                     };
-                    let current_call_fun = this.search(name, data.id);
+                    let current_call_fun = this.search(name, id);
                     let next_Swop_fun = (funs[0] || compatible).fun_body;
                     if (current_call_fun) {
-                        current_call_fun(next_Swop_fun, next, data, ...args);
+                        current_call_fun(next, next_Swop_fun, data, ...args);
+                        resolve(true);
                     }
@@ -122,13 +159,12 @@ });
     get_queue(name) {
-        const compatible = this.store[name] || { queue: false };
+        const compatible = this.store[name] || [{ queue: false }];
         return compatible.queue;
     }
     get_funs(name) {
-        const compatible = this.store[name] || { funs: false };
+        const compatible = this.store[name] || [{ funs: false }];
         return compatible.funs;
     }
 }
-export function CreateSwop(...args) {
-    return new Swop(...args);
+export function CreateSwop(opions) {
+    return new Swop(opions);
 }
-//# sourceMappingURL=data:application/json;base64,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

build/tool.d.ts

@@ -15,3 +15,2 @@ export declare type IdentifierJson = 'stringify' | 'parse';
 export declare class Tool implements ToolTypes {
-    constructor();
     random_str(range?: number): string;
@@ -21,1 +20,2 @@ sync_promise(): syncPromiseReturn;
 }
+export declare function warn(error_text: string, is_warn?: boolean): void;

build/tool.js

 function sync_promise() {
     let resolve;
     let reject;
-    const _promise = new Promise((re, rj) => {
-        resolve = re;
-        reject = rj;
+    const _promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
     });
@@ -26,10 +26,8 @@ return { promise: _promise, resolve, reject };
     }
-    return str;
+    return str + '_:_swopid';
 }
 export class Tool {
-    constructor() { }
     random_str(range) {
         return random_str();
     }
-    ;
     sync_promise() {
@@ -42,2 +40,8 @@ return sync_promise();
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9vbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL2xpYi90b29sLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQWdCQTtJQUNFLElBQUksT0FBTyxDQUFBO0lBQ1gsSUFBSSxNQUFNLENBQUE7SUFFVixNQUFNLFFBQVEsR0FBa0IsSUFBSSxPQUFPLENBQUMsQ0FBQyxFQUFFLEVBQUUsRUFBRSxFQUFFLEVBQUU7UUFDckQsT0FBTyxHQUFHLEVBQUUsQ0FBQTtRQUNaLE1BQU0sR0FBRyxFQUFFLENBQUE7SUFDYixDQUFDLENBQUMsQ0FBQTtJQUVGLE1BQU0sQ0FBQyxFQUFFLE9BQU8sRUFBQyxRQUFRLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxDQUFBO0FBQzlDLENBQUM7QUFHRCxzQkFBdUIsSUFBYSxFQUFFLFVBQXlCLEVBQUUsTUFBYTtJQUM1RSxJQUFJLENBQUM7UUFDSCxNQUFNLENBQUMsQ0FBQyxJQUFJLENBQVMsVUFBVSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUMxQyxDQUFDO0lBQUMsS0FBSyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztRQUNmLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNkLE1BQU0sQ0FBQyxJQUFJLENBQUM7SUFDZCxDQUFDO0FBQ0gsQ0FBQztBQUlELG9CQUFxQixLQUFLLEdBQUcsRUFBRTtJQUM3QixNQUFNLFNBQVMsR0FBVSxxRkFBcUYsQ0FBQztJQUMvRyxNQUFNLFNBQVMsR0FBa0IsR0FBRyxFQUFFLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLEdBQUcsU0FBUyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7SUFDMUYsSUFBSSxHQUFHLEdBQVUsRUFBRSxDQUFDO0lBRXBCLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsS0FBSyxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUM7UUFDL0IsR0FBRyxJQUFJLFNBQVMsQ0FBQyxTQUFTLEVBQUUsQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFFRCxNQUFNLENBQUMsR0FBRyxDQUFDO0FBQ2IsQ0FBQztBQVFELE1BQU07SUFDSixnQkFBZ0IsQ0FBQztJQUVWLFVBQVUsQ0FBRSxLQUFhO1FBQzlCLE1BQU0sQ0FBQyxVQUFVLEVBQUUsQ0FBQTtJQUNyQixDQUFDO0lBQUEsQ0FBQztJQUVLLFlBQVk7UUFDakIsTUFBTSxDQUFDLFlBQVksRUFBRSxDQUFDO0lBQ3hCLENBQUM7SUFFTSxZQUFZLENBQUUsSUFBUSxFQUFFLFVBQXlCLEVBQUUsTUFBYTtRQUNyRSxNQUFNLENBQUMsWUFBWSxDQUFDLElBQUksRUFBRSxVQUFVLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDaEQsQ0FBQztDQUNGIn0=
+export function warn(error_text, is_warn = false) {
+    const message = `${error_text} --- from Swop.js.`;
+    if (!is_warn) {
+        throw Error(message);
+    }
+    console.warn(message);
+}

package.json

 {
   "name": "swop-store",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Swop is a small library for data interaction with clients.",
@@ -5,0 +5,0 @@ "main": "./build/index.js",

README.md

@@ -1,1 +0,396 @@
-# Welcome to the Swop  🎉🎉🎉
+# Welcome to the [Swop][npm_Swop]  🎉🎉🎉
+
+swop 是一个用于`JavaScript`与客户端进行数据交互应用程序，他提供了简洁的`api`来帮助开发者来做这些事情。
+
+## swop 的来源
+      
+在我们与客户端交互的时候，大量的数据散落在项目各个文件，或者集中于繁琐的`redux`和`window`对象之中，管理维护困难，操作麻烦，使得开发效率很低。
+
+## swop 要解决什么样的问题
+      
+swop 使用[`aop`][aop_wiki]的理念进行设计开发，通过对于数据的阶段式操作来做一些事情，类似`express`和`redux`swop 能让开发者更好的处理数据，更好的异步和错误处理。
+
+## API
+### options
+  - json_stringify（default false） ——
+  于客户端交互时是否让 swop 对传输的数据进行json stringify。
+
+  - json_parse（default false） ——
+  客户端响应时是否让 swop 对传输的数据进行json parse。
+
+### [swop 类 api][swop_api]
+  - [call][call]
+  - [response][response]
+  - [create][create]
+  - [use][use]
+  - [get_all_data][get_all_data]
+  - [get_queue][get_queue]
+  - [get_funs][get_funs]
+  - [clear_polling][clear_polling]
+
+### [states api][states_api]
+  - [get][get]
+  - [set][set]
+  - [subscribe][subscribe]
+  - [remove_all_sub][remove_all_sub]
+  - [polling][polling]
+
+### 实例化 swop
+      
+swop 可以通过两种方式来实例化。
+
+```javascript
+  import { Swop, CreateSwop } from 'swop-data';
+
+  const S = new Swop(options);
+
+  // 或者你可以用 swop 提供的创建实例的函数
+  const S = CreateSwop(options);
+
+  S.create('dataOne', 1);
+
+  S.dataOne.set(2).get();
+```
+如果你是用`typescript`进行的开发
+```typescript
+  import { Swop, CreateSwop } from 'swop-data';
+  import {
+    Swop,
+    CreateSwop,
+    ContainerDataTypes as C,
+  } from 'swop-data';
+
+  export type A = C<I, keyof D>;
+
+  // 需要的接口在这里添加
+  export type I =
+    'interfaceOne';
+
+  // 实时变化数据存储容器
+  export type D = {
+    "dataOne": A;
+    "dataTwo": A;
+    "dataThree": A;
+  }
+
+  /**
+   * 通过 new 来创建的实例，在调用 create 方法
+   * 绑定数据后，没有办法通过实例拿到绑定属性的类型
+   */
+  const S = new Swop<I, D>(options);
+  S.creata('dataOne');
+  // 这种情况下 dataOne 的类型没有办法推断出来，但有两种办法可以拿到绑定数据的类型 
+  //  S.dataOne.XX
+
+  // 第一种，使用 types 属性
+  S.types.dataOne.get();
+
+  // 第二种，用 swop 提供的实例函数来创建实例
+  interface _Swop extends Swop<I, D>, D {}
+  const S = CreateSwop<_Swop>(options);
+  S.dataOne.get();
+
+  // 第三种，如果你不需要知道绑定属性的类型
+  S['dataOne'].get();
+```
+## swop 类 api
+### call
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+call 方法是于客户端进行通信的入口函数，他需要传入一个name字符和需要发送的数据。
+
+```javascript
+  // name 是于客户端交互的接口名
+  // data 传输给客户端的数据，默认为 null
+  // call 方法会返回一个 promise
+  // value 是客户端返回数据
+  S.call(name, data).then(([value, args]) => {
+    ...
+    args.next();
+  }).catch(err => {
+    ...
+  })
+
+  // 如果不需要对错误进行处理，你可以使用 AsyncFunction 进行更好的流程处理
+  async function call_height () {
+    const data = await S.call(name, data)
+    ...
+  }
+```
+
+```javascript
+  // 客户端的响应会以队列的形式进行触发，所以你可以这里对数据做一些传递
+  S.call(name).then(([value, args]) => {
+    /**
+     * 我们可以在这里拿到客户端的下一次响应
+     * args 有三个值
+     *  next : 下一次的响应（如果当前环境正在被调用，而下一次响应还没有到达，此时next是一个空函数）不管next函数是否是一个空函数，都必须调用，否则可能会出现下一次响应没有办法触发的情况
+     *  params : 上一次传过来的数据
+     *  nextSwopFun : 下一次的 call
+     */
+
+    args.next(`上一次的响应值为：${value}`);
+  })
+```
+
+### response
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+response 方法是客户端的入口函数。返回一个promise。
+
+```javascript
+  // 我们假设客户端响应统一在 window 上的 callback 方法上
+  window.callback = data => S.response(data);
+
+  // or
+  window.callback = data => {
+    S.response(data).then(_ => {
+      console.log('success');
+    }).catch(err => {
+      ...
+    })
+  };
+```
+
+### create
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+create 方法会创建一个绑定属性和绑定数据，返回值为`this`。
+
+```javascript
+  /**
+   * attr_name : 绑定数据名
+   * default_value : 创建绑定数据时默认值
+   * read_only : 数据是否只读
+   * 需要注意的是，当创建的数据是只读数据时，直接修改此数据的值也是不被允许的
+  */
+  S.create(attr_name, default_value, read_only)
+   .create(attr_name);
+
+  // 当创建一个绑定属性后，会在 swop 实例上生成一同名的绑定属性
+  // 需要注意的事项可以看实例化时的注释
+```
+
+### use
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+use 方法是 swop 提供的一个中间件函数，你可以通过 use 方法来注入一些中间件，中间件的注入与*先后顺序*相关，use 方法返回的是`this`，所以你可以像 jQuery 那样链式调用。
+
+```javascript
+  // name match字符，接口名或者'*'，当为通配符的时候，所有的接口都会匹配上
+  // val 有两个属性 value 和 match 
+  S.use(name, val => {
+    // 需要注意的是，use 方法的回调参数，swop 改成了引用的方式，所以你不需要纠结这里怎么没有`return`关键字
+    // 当然，这里如果你要对响应数据做些修改，你不应该用解构，除非你要做的事情与源数据没什么关系
+    if (typeof val.value === 'string') {
+      val.value = JSON.parse(val.value);
+    }
+  })
+
+  // bad
+  S.use(name, [value, match] => {
+    ...
+  })
+```
+
+### get_all_data
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+get_all_data 能够获取所有的绑定数据。
+
+```javascript
+  const all_stata = S.get_all_data();
+```
+
+### get_queue
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+swop 把当前接口的所有响应都放到一个队列里面，get_queue 方法会返回当前接口的响应队列
+
+```javascript
+  const queqe = S.get_queue(name);
+```
+
+### get_funs
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+当调用 call 方法与客户端进行数据交互时，会生成一个响应集合，每个集合由一个`fun_body`和`id`组成。get_funs 能够得到当前接口的所有响应集合
+
+```javascript
+  const funs = S.get_funs(name);
+
+  // 手动响应
+  const ids = funs.map(val => val.id);
+  ids.forEach((id, i) => {
+    S.response(JSON.stringify({
+      id,
+      origin_data: {
+        xx: 'xxx',
+      }
+    }))
+  })
+```
+
+### clear_polling
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+clear_polling 方法清除绑定属性的轮询。如果`name`为空，则清空所有绑定属性的轮询，返回值为`this`。
+
+```javascript
+  S.clear_polling(name);
+```
+
+
+## states api
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+当通过`create`api创建一个静态属性后，每个静态属性都会生成对应的方法，需要注意的是当生成的绑定数据是`readOnly`时，当前绑定属性只有`get`方法。
+
+- 假定以下 **api** 描述的绑定属性名为 dataOne。
+### get
+```javascript
+  const data = S.dataOne.get();
+```
+
+### set
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+set 方法会给当前绑定数据重新复制，返回值是当前绑定属性
+```javascript
+  S.dataOne.set(1);
+  // or
+  S.dataOne.set(1).get();
+
+  // 我们可以通过中间件做一些数据的更改
+  S.use('dataOne', val => val.value *= 100);
+
+  S.dataOne.set(1).get(); // 100
+
+  // 但是最常用的应该是客户端数据上报时用，假定客户端上报于 window.report
+  window.report = (data_name, data) => {
+    S[data_name].set(data);
+  }
+```
+
+### subscribe
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+subscribe 方法会对绑定数据进行监听，返回一个 remove 函数，用于注销当前的监听。
+
+```javascript
+  // S.dataOne.subscribe(fun, once);
+  // fun : 监听回调接受两个参数，分别为新值和旧值
+  // once : 此次监听是否只触发一次
+  S.create('dataOne');
+
+  const remove = S.dataOne.subscribe((new_value, old_value) => {
+    document.body.innerHTML = new_value;
+
+    // 如果你是在使用 react 进行开发，你可以
+    this.setState({
+      xx: new_value,
+    })
+  }, true);
+
+  // 你可以在适当的时机注销掉这个监听
+  remove();
+```
+
+### remove_all_sub
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+subscribe 方法会对绑定数据进行监听，需要手动一个个的注销掉监听，你会不会觉得太麻烦呢？remove_all_sub 就是一个可以省事的 api，返回值为`this`。
+
+```javascript
+  // 使用起来也很简单
+  S.dataOne.remove_all_sub();
+```
+
+### polling
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+polling 会不停的对客户端进行 call，以此更新当前绑定数据的值，返回值为 stop 函数，用于终止轮询。
+
+```javascript
+  // 如果你自己对绑定属性的值进行更新，你可以这样做
+  let interval;
+  function polling () {
+    const get = setInterval(async _ => {
+      const data = await S.call('interface', data);
+      S.dataOne.set(data);
+
+      if (S.get_funs().length < 50) { return; }
+
+      interval = setInterval(_ => {
+        // 预防无限注入，导致大的内存开销
+        if ( S.get_funs().length < 50) {
+          clearInterval(interval);
+          interval = null;
+          polling();
+        }
+      }, 100)
+    }, 100)
+  }
+```
+
+```javascript
+  // swop 提供了 polling 来轮询获取数据，需要传入的三个参数都是可选的
+  // interface_name : 需要轮询的接口，默认与当前的绑定属性名相同
+  // data : 轮询时需要传入的数据
+  // hook_fun : 轮询时每次响应的钩子函数
+
+  const stop = S.dataOne.polling('interfaceOne', '', data => {
+    ...
+  });
+
+  stop();
+
+  // 但最常用的应该是
+  S.dataOne.subscribe(new_value => {
+    // react
+    this.setState({
+      xx: new_value,
+    })
+  })
+
+  S.dataOne.polling();
+```
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+polling 方法在内部没用采用定时器的方法来轮询，不会带来大的内存开销。关于清除所有绑定属性的轮询，可以看这里 [clear_polling][clear_polling]。
+
+## 约定
+swop 使用约定好的数据格式与客户端进行交互，这需要客户端的开发者配合。
+
+在 JavaScript 层面，swop 会把数据转换成
+```
+{
+  origin_data: xxx（真正需要发送的数据）,
+  id: xxx（swop 生成的一段随机字符数）,
+}
+```
+
+相应的，响应数据也应该保证统一的格式
+```
+{
+  origin_data: xx（真正需要响应的数据）,
+  id: xx（swop 生成的id，id 是必须的），
+}
+```
+
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+id 和 origin_data 是唯一约定好的字段名，不应该带有其他的数据字段，不同的是，响应数据的格式是需要客户端的开发者手动转换成我们需要的格式，而 swop 会帮 JavaScript 开发者来做转换，id 是两者之间通信的凭证，swop 必须依靠 id 才能找到相应的响应集合。
+
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+如果响应数据的格式是 json，但在初始化实例的时候并没有让 swop 做 json 的解析，那么 swop 会通过正则表达式来截取真正需要的数据，需要注意带来的运行时开销。
+
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+绑定数据的更新也不应该通过 polling 函数来实现更新，客户端应该在数据发生变化时，数据上报给 JavaScript，通过绑定属性的 [set][set] 方法实现更新
+
+
+[npm_Swop]:https://www.npmjs.com/package/swop-store
+[aop_wiki]: https://zh.wikipedia.org/wiki/%E9%9D%A2%E5%90%91%E4%BE%A7%E9%9D%A2%E7%9A%84%E7%A8%8B%E5%BA%8F%E8%AE%BE%E8%AE%A1
+
+[swop_api]:https://github.com/imtaotao/Swop#swop-%E7%B1%BB-api-1
+[call]:https://github.com/imtaotao/Swop#call
+[response]:https://github.com/imtaotao/Swop#response
+[create]:https://github.com/imtaotao/Swop#create
+[use]:https://github.com/imtaotao/Swop#use
+[get_all_data]:https://github.com/imtaotao/Swop#get_all_data
+[get_queue]:https://github.com/imtaotao/Swop#get_queue
+[get_funs]:https://github.com/imtaotao/Swop#get_funs
+[clear_polling]:https://github.com/imtaotao/Swop#clear_polling
+
+[states_api]:https://github.com/imtaotao/Swop#states-api-1
+[get]:https://github.com/imtaotao/Swop#get
+[set]:https://github.com/imtaotao/Swop#set
+[subscribe]:https://github.com/imtaotao/Swop#subscribe
+[remove_all_sub]:https://github.com/imtaotao/Swop#remove_all_sub
+[polling]:https://github.com/imtaotao/Swop#polling
+

No alert changes

Improved metrics

Total package byte prevSize

32406

increased by4.15%

Lines of code

575

increased by16.63%

Number of lines in readme file

397

increased by19750%

No dependency changes