byteoss 1.0.0

package/README.md

@@ -0,0 +1,109 @@
+����һ����̬��Դ��
+
+## ��װ
+
+```
+yarn add topic
+```
+
+# ����
+
+### publish
+
+�����¼�
+
+```typescript
+import { topic } from 'topic';
+
+topic.publish('name', 'message');
+```
+
+### subscribe
+
+�����¼�
+
+```typescript
+topic.subscribe('who', (name, age) => {
+  console.log('Hello' + name + ', are you ' + age + 'old?');
+});
+
+topic.publish('who', 'Tom', 12);
+```
+
+### subscribeOnce
+
+�����¼�������һ�κ�����ȡ��
+
+```typescript
+topic.subscribeOnce('who', (name) => {
+  console.log('Hello ' + name);
+});
+
+// ��һ���������յ���Ϣ
+topic.publish('who', 'Tom');
+// û�ж�������
+topic.publish('who', 'Tom');
+```
+
+### unsubscribe
+
+ȡ�������¼�
+
+```typescript
+const handle = topic.subscribe('who', (name) => {
+  console.log('Hello ' + name);
+});
+
+// ��һ���������յ���Ϣ
+topic.publish('who', 'Tom');
+// ��һ���������յ���Ϣ
+topic.publish('who', 'John');
+
+handle.unsubscribe();
+// û�ж�������
+topic.publish('who', 'Tom');
+```
+
+### keep + release
+
+���������¼�
+
+```typescript
+const sub1 = topic.subscribe('who', (name) => {
+  console.log('Hello ' + name);
+});
+
+// sub1 �յ���Ϣ
+const handle = topic.keep('who', true, 'Tom');
+
+// sub2 �����յ���Ϣ
+const sub2 = topic.subscribe('who', (name) => {});
+
+// sub3 �����յ���Ϣ
+const sub3 = topic.subscribe('who', (name) => {});
+
+handle.release();
+
+// sub3 û���յ���Ϣ
+const sub3 = topic.subscribe('who', (name) => {});
+```
+
+# ʹ�� TS �����Զ����¼�
+
+ʵ����� topic ���ǻ������ŵģ�������ȫ��ҵ����߾ֲ�ҵ��
+
+```typescript
+import { Topic } from 'topic';
+
+const customTopic = new Topic<{
+  foo: [name: string];
+  bar: [name: string, age: number];
+  // ������봫����಻�ɿص��¼����ƣ���ȡ����������ע��
+  // [more: string]: any[];
+}>();
+
+// ���ڱ༭������ʾ��name��������
+customTopic.subscribe('foo', (name) => {});
+// ���ڱ༭��֪���ڶ�������Ӧ�ô�ʲô������
+customTopic.publish('foo', 'Tom');
+```

package/index.js

@@ -0,0 +1,147 @@
+"use strict";
+function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+Object.defineProperty(exports, "__esModule", {
+    value: true
+}); // index.ts
+var when = function(deps) {
+    return typeof deps === "boolean" ? deps : deps();
+};
+var aps = Array.prototype.slice;
+var counter = 0;
+var Topic = /*#__PURE__*/ function() {
+    function _class() {
+        _classCallCheck(this, _class);
+        this.listeners = {};
+        this.origins = {};
+        this.keeps = [];
+    }
+    _createClass(_class, [
+        {
+            key: "publish",
+            value: function publish() {
+                var name = arguments[0];
+                var args = aps.call(arguments, 1);
+                var listeners = this.origins[name] = this.listeners[name];
+                if (!listeners || !listeners.length) {
+                    return;
+                }
+                for(var i = 0; i < listeners.length; ++i){
+                    listeners[i].fn.apply(null, args);
+                }
+                this.origins[name] = void 0;
+            }
+        },
+        {
+            key: "subscribeOnce",
+            value: function subscribeOnce(name, fn) {
+                var executed = false;
+                var ref = {};
+                ref.token = this.subscribe(name, function() {
+                    fn.apply(null, arguments);
+                    if (ref.token) {
+                        ref.token.unsubscribe();
+                    } else {
+                        executed = true;
+                    }
+                });
+                if (executed) {
+                    ref.token.unsubscribe();
+                }
+                return ref.token;
+            }
+        },
+        {
+            key: "subscribe",
+            value: function subscribe(name, fn) {
+                var token = "Token_" + counter++;
+                var listeners = this.listeners[name];
+                if (listeners) {
+                    var origin = this.origins[name];
+                    if (origin && listeners === origin) {
+                        listeners = this.listeners[name] = listeners.slice(0);
+                    }
+                } else {
+                    listeners = this.listeners[name] = [];
+                }
+                listeners.push({
+                    token: token,
+                    fn: fn
+                });
+                if (this.keeps.length) {
+                    var keeps = this.keeps.filter(function(item) {
+                        return item.name === name && when(item.shouldPublish);
+                    });
+                    for(var i = 0; i < keeps.length; ++i){
+                        fn.apply(null, keeps[i].args);
+                    }
+                }
+                return {
+                    unsubscribe: this.unsubscribe.bind(this, name, token)
+                };
+            }
+        },
+        {
+            key: "keep",
+            value: function keep() {
+                var name = arguments[0];
+                var shouldPublish = arguments[1];
+                var args = aps.call(arguments, 2);
+                var token = "Token_" + counter++;
+                when(shouldPublish) && this.publish.apply(this, [
+                    name
+                ].concat(args));
+                this.keeps.push({
+                    shouldPublish: shouldPublish,
+                    token: token,
+                    name: name,
+                    args: args
+                });
+                return {
+                    release: this.release.bind(this, token)
+                };
+            }
+        },
+        {
+            key: "unsubscribe",
+            value: function unsubscribe(name, token) {
+                var listeners = this.listeners[name];
+                if (!listeners || !listeners.length) {
+                    return;
+                }
+                this.listeners[name] = listeners.filter(function(item) {
+                    return item.token !== token;
+                });
+            }
+        },
+        {
+            key: "release",
+            value: function release(token) {
+                this.keeps = this.keeps.filter(function(item) {
+                    return item.token !== token;
+                });
+            }
+        }
+    ]);
+    return _class;
+}();
+var topic = new Topic();
+exports.Topic = Topic;
+exports.topic = topic;