@mujian/js-sdk 0.0.6-beta.33 → 0.0.6-beta.34

package/dist/umd/index.js

@@ -0,0 +1,484 @@
+/*! For license information please see index.js.LICENSE.txt */
+(function(root, factory) {
+    if ('object' == typeof exports && 'object' == typeof module) module.exports = factory();
+    else if ('function' == typeof define && define.amd) define([], factory);
+    else if ('object' == typeof exports) exports["RslibUmdExample"] = factory();
+    else root["RslibUmdExample"] = factory();
+})(globalThis, ()=>(()=>{
+        "use strict";
+        var __webpack_require__ = {};
+        (()=>{
+            __webpack_require__.d = (exports1, definition)=>{
+                for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                    enumerable: true,
+                    get: definition[key]
+                });
+            };
+        })();
+        (()=>{
+            __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+        })();
+        (()=>{
+            __webpack_require__.r = (exports1)=>{
+                if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+                    value: 'Module'
+                });
+                Object.defineProperty(exports1, '__esModule', {
+                    value: true
+                });
+            };
+        })();
+        var __webpack_exports__ = {};
+        __webpack_require__.r(__webpack_exports__);
+        __webpack_require__.d(__webpack_exports__, {
+            MujianSdk: ()=>MujianSdk,
+            EVENT: ()=>events_EVENT
+        });
+        /**
+  postmate - A powerful, simple, promise-based postMessage library
+  @version v1.5.2
+  @link https://github.com/dollarshaveclub/postmate
+  @author Jacob Kelley <jakie8@gmail.com>
+  @license MIT
+**/ var messageType = 'application/x-postmate-v1+json';
+        var maxHandshakeRequests = 5;
+        var _messageId = 0;
+        var postmate_es_generateNewMessageId = function() {
+            return ++_messageId;
+        };
+        var postmate_es_resolveOrigin = function(url) {
+            var a = document.createElement('a');
+            a.href = url;
+            var protocol = a.protocol.length > 4 ? a.protocol : window.location.protocol;
+            var host = a.host.length ? '80' === a.port || '443' === a.port ? a.hostname : a.host : window.location.host;
+            return a.origin || protocol + "//" + host;
+        };
+        var messageTypes = {
+            handshake: 1,
+            'handshake-reply': 1,
+            call: 1,
+            emit: 1,
+            reply: 1,
+            request: 1
+        };
+        var postmate_es_sanitize = function(message, allowedOrigin) {
+            if ('string' == typeof allowedOrigin && message.origin !== allowedOrigin) return false;
+            if (!message.data) return false;
+            if ('object' == typeof message.data && !('postmate' in message.data)) return false;
+            if (message.data.type !== messageType) return false;
+            if (!messageTypes[message.data.postmate]) return false;
+            return true;
+        };
+        var postmate_es_resolveValue = function(model, property) {
+            var unwrappedContext = 'function' == typeof model[property] ? model[property]() : model[property];
+            return postmate_es_Postmate.Promise.resolve(unwrappedContext);
+        };
+        var postmate_es_ParentAPI = /*#__PURE__*/ function() {
+            function ParentAPI(info) {
+                var _this = this;
+                this.parent = info.parent;
+                this.frame = info.frame;
+                this.child = info.child;
+                this.childOrigin = info.childOrigin;
+                this.events = {};
+                this.listener = function(e) {
+                    if (!postmate_es_sanitize(e, _this.childOrigin)) return false;
+                    var _ref = ((e || {}).data || {}).value || {}, data = _ref.data, name = _ref.name;
+                    if ('emit' === e.data.postmate) {
+                        if (name in _this.events) _this.events[name].call(_this, data);
+                    }
+                };
+                this.parent.addEventListener('message', this.listener, false);
+            }
+            var _proto = ParentAPI.prototype;
+            _proto.get = function(property) {
+                var _this2 = this;
+                return new postmate_es_Postmate.Promise(function(resolve) {
+                    var uid = postmate_es_generateNewMessageId();
+                    var transact = function transact(e) {
+                        if (e.data.uid === uid && 'reply' === e.data.postmate) {
+                            _this2.parent.removeEventListener('message', transact, false);
+                            resolve(e.data.value);
+                        }
+                    };
+                    _this2.parent.addEventListener('message', transact, false);
+                    _this2.child.postMessage({
+                        postmate: 'request',
+                        type: messageType,
+                        property: property,
+                        uid: uid
+                    }, _this2.childOrigin);
+                });
+            };
+            _proto.call = function(property, data) {
+                this.child.postMessage({
+                    postmate: 'call',
+                    type: messageType,
+                    property: property,
+                    data: data
+                }, this.childOrigin);
+            };
+            _proto.on = function(eventName, callback) {
+                this.events[eventName] = callback;
+            };
+            _proto.destroy = function() {
+                window.removeEventListener('message', this.listener, false);
+                this.frame.parentNode.removeChild(this.frame);
+            };
+            return ParentAPI;
+        }();
+        var postmate_es_ChildAPI = /*#__PURE__*/ function() {
+            function ChildAPI(info) {
+                var _this3 = this;
+                this.model = info.model;
+                this.parent = info.parent;
+                this.parentOrigin = info.parentOrigin;
+                this.child = info.child;
+                this.child.addEventListener('message', function(e) {
+                    if (!postmate_es_sanitize(e, _this3.parentOrigin)) return;
+                    var _e$data = e.data, property = _e$data.property, uid = _e$data.uid, data = _e$data.data;
+                    if ('call' === e.data.postmate) {
+                        if (property in _this3.model && 'function' == typeof _this3.model[property]) _this3.model[property](data);
+                        return;
+                    }
+                    postmate_es_resolveValue(_this3.model, property).then(function(value) {
+                        return e.source.postMessage({
+                            property: property,
+                            postmate: 'reply',
+                            type: messageType,
+                            uid: uid,
+                            value: value
+                        }, e.origin);
+                    });
+                });
+            }
+            var _proto2 = ChildAPI.prototype;
+            _proto2.emit = function(name, data) {
+                this.parent.postMessage({
+                    postmate: 'emit',
+                    type: messageType,
+                    value: {
+                        name: name,
+                        data: data
+                    }
+                }, this.parentOrigin);
+            };
+            return ChildAPI;
+        }();
+        var postmate_es_Postmate = /*#__PURE__*/ function() {
+            function Postmate(_ref2) {
+                var _ref2$container = _ref2.container, container = void 0 === _ref2$container ? void 0 !== container ? container : document.body : _ref2$container, model = _ref2.model, url = _ref2.url, name = _ref2.name, _ref2$classListArray = _ref2.classListArray, classListArray = void 0 === _ref2$classListArray ? [] : _ref2$classListArray;
+                this.parent = window;
+                this.frame = document.createElement('iframe');
+                this.frame.name = name || '';
+                this.frame.classList.add.apply(this.frame.classList, classListArray);
+                container.appendChild(this.frame);
+                this.child = this.frame.contentWindow || this.frame.contentDocument.parentWindow;
+                this.model = model || {};
+                return this.sendHandshake(url);
+            }
+            var _proto3 = Postmate.prototype;
+            _proto3.sendHandshake = function(url) {
+                var _this4 = this;
+                var childOrigin = postmate_es_resolveOrigin(url);
+                var attempt = 0;
+                var responseInterval;
+                return new Postmate.Promise(function(resolve, reject) {
+                    var reply = function reply(e) {
+                        if (!postmate_es_sanitize(e, childOrigin)) return false;
+                        if ('handshake-reply' === e.data.postmate) {
+                            clearInterval(responseInterval);
+                            _this4.parent.removeEventListener('message', reply, false);
+                            _this4.childOrigin = e.origin;
+                            return resolve(new postmate_es_ParentAPI(_this4));
+                        }
+                        return reject('Failed handshake');
+                    };
+                    _this4.parent.addEventListener('message', reply, false);
+                    var doSend = function() {
+                        attempt++;
+                        _this4.child.postMessage({
+                            postmate: 'handshake',
+                            type: messageType,
+                            model: _this4.model
+                        }, childOrigin);
+                        if (attempt === maxHandshakeRequests) clearInterval(responseInterval);
+                    };
+                    var loaded = function() {
+                        doSend();
+                        responseInterval = setInterval(doSend, 500);
+                    };
+                    if (_this4.frame.attachEvent) _this4.frame.attachEvent('onload', loaded);
+                    else _this4.frame.onload = loaded;
+                    _this4.frame.src = url;
+                });
+            };
+            return Postmate;
+        }();
+        postmate_es_Postmate.debug = false;
+        postmate_es_Postmate.Promise = function() {
+            try {
+                return window ? window.Promise : Promise;
+            } catch (e) {
+                return null;
+            }
+        }();
+        postmate_es_Postmate.Model = /*#__PURE__*/ function() {
+            function Model(model) {
+                this.child = window;
+                this.model = model;
+                this.parent = this.child.parent;
+                return this.sendHandshakeReply();
+            }
+            var _proto4 = Model.prototype;
+            _proto4.sendHandshakeReply = function() {
+                var _this5 = this;
+                return new postmate_es_Postmate.Promise(function(resolve, reject) {
+                    var shake = function shake(e) {
+                        if (!e.data.postmate) return;
+                        if ('handshake' === e.data.postmate) {
+                            _this5.child.removeEventListener('message', shake, false);
+                            e.source.postMessage({
+                                postmate: 'handshake-reply',
+                                type: messageType
+                            }, e.origin);
+                            _this5.parentOrigin = e.origin;
+                            var defaults = e.data.model;
+                            if (defaults) Object.keys(defaults).forEach(function(key) {
+                                _this5.model[key] = defaults[key];
+                            });
+                            return resolve(new postmate_es_ChildAPI(_this5));
+                        }
+                        return reject('Handshake Reply Failed');
+                    };
+                    _this5.child.addEventListener('message', shake, false);
+                });
+            };
+            return Model;
+        }();
+        const postmate_es = postmate_es_Postmate;
+        var events_EVENT = /*#__PURE__*/ function(EVENT) {
+            EVENT["MUJIAN_INIT"] = "mujian:init";
+            EVENT["MUJIAN_AI_CHAT_STOP"] = "mujian:ai:chat:stop";
+            EVENT["MUJIAN_AI_CHAT_COMPLETE"] = "mujian:ai:chat:complete";
+            EVENT["MUJIAN_AI_CHAT_APPLY_REGEX"] = "mujian:ai:chat:applyRegex";
+            EVENT["MUJIAN_AI_TEXT_GENERATE"] = "mujian:ai:text:generate";
+            EVENT["MUJIAN_AI_CHAT_MESSAGE_GET_ALL"] = "mujian:ai:chat:message:getAll";
+            EVENT["MUJIAN_AI_CHAT_PROJECT_GET_INFO"] = "mujian:ai:chat:project:getInfo";
+            EVENT["MUJIAN_AI_SETTINGS_PERSONA_GET_ACTIVE"] = "mujian:ai:settings:persona:getActive";
+            EVENT["MUJIAN_AI_SETTINGS_PERSONA_SET_ACTIVE"] = "mujian:ai:settings:persona:setActive";
+            EVENT["MUJIAN_AI_SETTINGS_MODEL_GET_ALL"] = "mujian:ai:settings:model:getAll";
+            EVENT["MUJIAN_AI_SETTINGS_MODEL_SET_ACTIVE"] = "mujian:ai:settings:model:setActive";
+            EVENT["MUJIAN_AI_SETTINGS_MODEL_GET_ACTIVE"] = "mujian:ai:settings:model:getActive";
+            EVENT["MUJIAN_AI_CHAT_MESSAGE_DELETE_ONE"] = "mujian:ai:chat:message:deleteOne";
+            EVENT["MUJIAN_AI_CHAT_MESSAGE_EDIT_ONE"] = "mujian:ai:chat:message:editOne";
+            EVENT["MUJIAN_AI_CHAT_MESSAGE_SWIPE"] = "mujian:ai:chat:message:swipe";
+            EVENT["MUJIAN_AI_CHAT_MESSAGE_GET_PROMPT"] = "mujian:ai:chat:message:getPrompt";
+            return EVENT;
+        }({});
+        const getInfo = async function() {
+            return await this.call(events_EVENT.MUJIAN_AI_CHAT_PROJECT_GET_INFO);
+        };
+        const getActive = async function() {
+            return await this.call(events_EVENT.MUJIAN_AI_SETTINGS_MODEL_GET_ACTIVE);
+        };
+        const setActive = async function(modelId) {
+            return await this.call(events_EVENT.MUJIAN_AI_SETTINGS_MODEL_SET_ACTIVE, {
+                modelId
+            });
+        };
+        const getAll = async function() {
+            return await this.call(events_EVENT.MUJIAN_AI_SETTINGS_MODEL_GET_ALL);
+        };
+        const persona_getActive = async function() {
+            return await this.call(events_EVENT.MUJIAN_AI_SETTINGS_PERSONA_GET_ACTIVE);
+        };
+        const persona_setActive = async function(personaId) {
+            return await this.call(events_EVENT.MUJIAN_AI_SETTINGS_PERSONA_SET_ACTIVE, {
+                personaId
+            });
+        };
+        const chat_complete = async function(message, onData, signal) {
+            return await this.call(events_EVENT.MUJIAN_AI_CHAT_COMPLETE, {
+                content: message
+            }, {
+                onData,
+                signal
+            });
+        };
+        const applyRegex = async function(props) {
+            return await this.call(events_EVENT.MUJIAN_AI_CHAT_APPLY_REGEX, props);
+        };
+        const continueComplete = async function(onData, signal) {
+            return await this.call(events_EVENT.MUJIAN_AI_CHAT_COMPLETE, {
+                isContinue: true
+            }, {
+                onData,
+                signal
+            });
+        };
+        const regenerate = async function(onData, signal) {
+            return await this.call(events_EVENT.MUJIAN_AI_CHAT_COMPLETE, {
+                isRegenerate: true
+            }, {
+                onData,
+                signal
+            });
+        };
+        const message_getAll = async function() {
+            return await this.call(events_EVENT.MUJIAN_AI_CHAT_MESSAGE_GET_ALL);
+        };
+        const messageDeleteOne = async function(messageId) {
+            return await this.call(events_EVENT.MUJIAN_AI_CHAT_MESSAGE_DELETE_ONE, {
+                messageId
+            });
+        };
+        const messageEditOne = async function(messageId, content) {
+            return await this.call(events_EVENT.MUJIAN_AI_CHAT_MESSAGE_EDIT_ONE, {
+                messageId,
+                content
+            });
+        };
+        const messageSwipe = async function(messageId, swipeId) {
+            return await this.call(events_EVENT.MUJIAN_AI_CHAT_MESSAGE_SWIPE, {
+                messageId,
+                swipeId
+            });
+        };
+        const getPrompt = async function(messageId) {
+            return await this.call(events_EVENT.MUJIAN_AI_CHAT_MESSAGE_GET_PROMPT, {
+                messageId
+            });
+        };
+        const generate = async function() {
+            return await this.call(events_EVENT.MUJIAN_AI_TEXT_GENERATE, {
+                content: 'q'
+            });
+        };
+        const saveGame = async function() {};
+        const loadGame = async function() {};
+        class MujianSdk {
+            constructor(){}
+            static getInstance() {
+                if (!window.$mujian) window.$mujian = new MujianSdk();
+                return window.$mujian;
+            }
+            parent = null;
+            ready = false;
+            get isReady() {
+                return this.ready;
+            }
+            pendingRequests = new Map();
+            async init() {
+                const handshake = new postmate_es.Model({
+                    reply: ({ id, complete, data, error })=>{
+                        const call = this.pendingRequests.get(id);
+                        if (!call) return;
+                        if (error) {
+                            call.reject(error);
+                            this.pendingRequests.delete(id);
+                            return;
+                        }
+                        call.onData?.(data);
+                        if (complete) {
+                            call.onComplete?.();
+                            call.resolve(data);
+                            this.pendingRequests.delete(id);
+                        }
+                    }
+                });
+                try {
+                    const parent = await handshake;
+                    this.ready = true;
+                    this.parent = parent;
+                    console.log('mujian sdk client init');
+                    await this.call(events_EVENT.MUJIAN_INIT);
+                } catch (error) {
+                    console.log('init error', error);
+                }
+            }
+            emit(event, data) {
+                if (!this.ready) throw new Error('Mujian is not initialized');
+                this.parent?.emit(event, data);
+            }
+            nextCallId = 0;
+            getCallId() {
+                const id = this.nextCallId;
+                this.nextCallId += 1;
+                return id;
+            }
+            async call(event, data, controller) {
+                if (!this.ready) throw new Error('Mujian is not initialized');
+                const callId = this.getCallId();
+                return new Promise((resolve, reject)=>{
+                    this.pendingRequests.set(callId, {
+                        resolve,
+                        reject,
+                        ...controller
+                    });
+                    this.emit(event, {
+                        id: callId,
+                        data
+                    });
+                    controller?.signal?.addEventListener('abort', ()=>{
+                        this.emit(events_EVENT.MUJIAN_AI_CHAT_STOP, {
+                            id: callId
+                        });
+                    });
+                });
+            }
+            ai = {
+                chat: {
+                    project: {
+                        getInfo: getInfo.bind(this)
+                    },
+                    settings: {
+                        model: {
+                            getAll: getAll.bind(this),
+                            getActive: getActive.bind(this),
+                            setActive: setActive.bind(this)
+                        },
+                        persona: {
+                            getActive: persona_getActive.bind(this),
+                            setActive: persona_setActive.bind(this)
+                        }
+                    },
+                    complete: chat_complete.bind(this),
+                    applyRegex: applyRegex.bind(this),
+                    continue: continueComplete.bind(this),
+                    regenerate: regenerate.bind(this),
+                    message: {
+                        getAll: message_getAll.bind(this),
+                        deleteOne: messageDeleteOne.bind(this),
+                        editOne: messageEditOne.bind(this),
+                        swipe: messageSwipe.bind(this),
+                        getPrompt: getPrompt.bind(this)
+                    }
+                },
+                text: {
+                    complete: generate.bind(this)
+                }
+            };
+            ui = {};
+            util = {
+                cn: ()=>{
+                    console.log('cn');
+                }
+            };
+            hybrid = {};
+            player = {};
+            game = {
+                assets: ()=>{
+                    console.log('assets');
+                },
+                saves: {
+                    saveGame: saveGame.bind(this),
+                    loadGame: loadGame.bind(this)
+                },
+                ranking: ()=>{
+                    console.log('ranking');
+                }
+            };
+        }
+        return __webpack_exports__;
+    })());

package/dist/umd/index.js.LICENSE.txt

@@ -0,0 +1,7 @@
+/**
+  postmate - A powerful, simple, promise-based postMessage library
+  @version v1.5.2
+  @link https://github.com/dollarshaveclub/postmate
+  @author Jacob Kelley <jakie8@gmail.com>
+  @license MIT
+**/