hzengine-core 0.1.2-dev

package/dist/script/strtools.js

@@ -0,0 +1,157 @@
+/**
+ * 将一行字符串切割为(str,quoted)[]的形式
+ * @param str
+ * @returns
+ */
+export function splitStr2Objs(str) {
+    // console.log(`splitStr2Objs: ${str}`);
+    let res = [];
+    let len = str.length;
+    let p = 0;
+    while (p < len) {
+        while (p < len && str[p] === " ")
+            ++p; // find first not space
+        if (p === len)
+            return res;
+        if (str[p] === '"') {
+            // find next `"`
+            let q = p + 1;
+            while (q < len && str[q] !== '"') {
+                if (str[q] === "\\")
+                    q += 2;
+                else
+                    ++q;
+            }
+            if (q >= len)
+                throw "Quote not completed";
+            let resstr = str.slice(p + 1, q);
+            //   console.log(`Transformed[${res.length}]:\n${transformStr(resstr)}`);
+            let transformedStr = "error";
+            try {
+                transformedStr = transformStr(resstr);
+            }
+            catch (e) {
+                throw "该字符串中的转义字符有错误：" + resstr;
+            }
+            res.push({ str: transformedStr, isQuoted: true });
+            p = q + 1;
+        }
+        else if (str[p] === "[") {
+            // find next `]`
+            let q = p + 1;
+            while (q < len && str[q] !== "]") {
+                // if (str[q] === "\\") q += 2;
+                // else ++q;
+                ++q;
+            }
+            if (q >= len)
+                throw "square brackets not completed";
+            let resstr = str.slice(p + 1, q);
+            res.push({ str: resstr, isSquared: true });
+            p = q + 1;
+        }
+        else if (str[p] === "(") {
+            // find next `)`
+            let q = p + 1;
+            while (q < len && str[q] !== ")") {
+                // if (str[q] === "\\") q += 2;
+                // else ++q;
+                ++q;
+            }
+            if (q >= len)
+                throw "round brackets not completed";
+            let resstr = str.slice(p + 1, q);
+            res.push({ str: resstr, isRounded: true });
+            p = q + 1;
+        }
+        else {
+            let q = p + 1;
+            while (q < len && str[q] !== " " && str[q] !== '"' && str[q] !== "(" && str[q] !== "[")
+                ++q; // find first space/quote after this
+            let resstr = str.slice(p, q);
+            //   console.log(transformStr(resstr));
+            res.push({ str: resstr, isQuoted: false });
+            p = q;
+        }
+    }
+    return res;
+}
+export function mergeObjs2Str(objs) {
+    return objs
+        .map((obj) => obj.isQuoted ? `"${obj.str}"` : obj.isSquared ? `[${obj.str}]` : obj.isRounded ? `(${obj.str})` : obj.str)
+        .join(" ");
+}
+export function splitStr2Strs(str) {
+    return splitStr2Objs(str).map((obj) => obj.isQuoted ? `"${obj.str}"` : obj.str);
+}
+/**
+ * 转义一遍字符串，使其中\n等变成对应字符（可能报错）
+ * @param str
+ * @returns
+ */
+export function transformStr(str) {
+    return JSON.parse(`"${str}"`);
+}
+// 翻译hzengine script插值字符串
+// 语法："...[expression]..."
+// 如果希望在字符串中显示`[`，请使用两个`[`，如`"[[正常显示而不被当作表达式的文字]]"`
+export function parseInterpolatedStr(str) {
+    let len = str.length;
+    let p = 0;
+    let expr_record = [];
+    while (p < len) {
+        // 寻找第一个`[`
+        while (p < len && str[p] !== "[")
+            ++p;
+        if (p >= len)
+            break;
+        // 判断是否是两个`[`
+        if (str[p] === "[" && str[p + 1] === "[") {
+            p += 2;
+            continue;
+        }
+        // 寻找第一个`]`
+        let q = p + 1;
+        while (q < len && str[q] !== "]") {
+            ++q;
+            // 判断是否是两个`]`
+            while (q < len && str[q] === "]" && str[q + 1] === "]") {
+                q += 2;
+            }
+        }
+        if (q >= len) {
+            // 没有找到`]`，报错
+            throw `Interpolated string lose closing bracket: ${str}`;
+        }
+        expr_record.push([p, q]);
+        p = q + 1;
+    }
+    let left = 0, right = len;
+    let res = [];
+    for (let i = 0; i < expr_record.length; ++i) {
+        let [l, r] = expr_record[i];
+        if (l > left)
+            res.push({ str: str.slice(left, l), isExpression: false });
+        res.push({ str: str.slice(l + 1, r), isExpression: true });
+        left = r + 1;
+    }
+    if (left < right)
+        res.push({ str: str.slice(left, right), isExpression: false });
+    return res;
+}
+export function removeComment(str) {
+    let quoteNotClosed = false;
+    let len = str.length;
+    for (let i = 0; i < len; ++i) {
+        if (quoteNotClosed && str[i] === `\\`) {
+            ++i;
+        }
+        else if (str[i] === `"`) {
+            quoteNotClosed = !quoteNotClosed;
+        }
+        else if (str[i] === "#" && !quoteNotClosed) {
+            return str.slice(0, i);
+        }
+    }
+    return str;
+}

package/dist/storage/decorator.js

@@ -0,0 +1,260 @@
+import { Async } from "../async/index.js";
+/**
+ * 存档属性装饰器
+ * @param store_key 保存数据到存档数据对象的key
+ * @returns
+ */
+export function Save(store_key) {
+    return function (target, context) {
+        context.addInitializer(function () {
+            Async.nextTick(() => {
+                const core = this._core;
+                core.on("initArchiveData", () => {
+                    core.storage.setSaveableData(core.storage.archiveData, true, target.get.call(this), ...store_key.split("."));
+                });
+                core.on("beforeSaveArchive", () => {
+                    core.storage.setSaveableData(core.storage.archiveData, false, target.get.call(this), ...store_key.split("."));
+                });
+                core.on("afterLoadArchive", () => {
+                    let dataInArchive = core.storage.getSaveableData(core.storage.archiveData, false, ...store_key.split("."));
+                    this._core.debug.log(`Load Data from Archive, store_key: ${store_key}, dataInArchive: ${JSON.stringify(dataInArchive)}`);
+                    target.set.call(this, dataInArchive);
+                });
+            });
+        });
+        if (context.kind !== "accessor") {
+            throw new Error("ArchiveStateAccessor只能用于accessor属性");
+        }
+        return {
+            get() {
+                target = target;
+                return archiveStateGetter(this, store_key, target.get);
+            },
+            set(value) {
+                target = target;
+                archiveStateSetter(this, store_key, target.set, value);
+            },
+        };
+    };
+}
+/**
+ * 存档属性装饰器
+ * @param store_key 保存数据到存档数据对象的key
+ * @returns
+ */
+export function CustomSave(store_key, serializer, deserializer) {
+    return (target, context) => {
+        if (context.kind !== "accessor") {
+            throw new Error("ArchiveStateAccessor只能用于accessor属性");
+        }
+        context.addInitializer(function () {
+            Async.nextTick(() => {
+                const core = this._core;
+                core.on("initArchiveData", () => {
+                    core.storage.setSaveableData(core.storage.archiveData, true, serializer.call(this, target.get.call(this)), ...store_key.split("."));
+                });
+                core.on("beforeSaveArchive", () => {
+                    core.storage.setSaveableData(core.storage.archiveData, false, serializer.call(this, target.get.call(this)), ...store_key.split("."));
+                });
+                core.on("afterLoadArchive", () => {
+                    let dataInArchive = core.storage.getSaveableData(core.storage.archiveData, false, ...store_key.split("."));
+                    this._core.debug.log(`Load Data from Archive, store_key: ${store_key}, dataInArchive: ${JSON.stringify(dataInArchive)}`);
+                    target.set.call(this, deserializer.call(this, dataInArchive));
+                });
+            });
+        });
+        return {
+            get() {
+                target = target;
+                return archiveStateGetterWithSerializer(this, store_key, target.get, serializer);
+            },
+            set(value) {
+                target = target;
+                archiveStateSetterWithDeserializer(this, store_key, target.set, value, deserializer);
+            },
+        };
+    };
+}
+export function SaveGetter(store_key) {
+    return (target, context) => {
+        context.addInitializer(function () {
+            Async.nextTick(() => {
+                const core = this._core;
+                core.on("initArchiveData", () => {
+                    core.storage.setSaveableData(core.storage.archiveData, true, target.call(this), ...store_key.split("."));
+                });
+                core.on("beforeSaveArchive", () => {
+                    core.storage.setSaveableData(core.storage.archiveData, false, target.call(this), ...store_key.split("."));
+                });
+            });
+        });
+        if (context.kind !== "getter") {
+            throw new Error("ArchiveStateGetter只能用于getter属性");
+        }
+        return function () {
+            let val = archiveStateGetter(this, store_key, target);
+            return val;
+        };
+    };
+}
+export function CustomSaveGetter(store_key, serializer) {
+    return (target, context) => {
+        if (context.kind !== "getter") {
+            throw new Error("ArchiveStateGetter只能用于getter属性");
+        }
+        context.addInitializer(function () {
+            Async.nextTick(() => {
+                const core = this._core;
+                core.on("initArchiveData", () => {
+                    core.storage.setSaveableData(core.storage.archiveData, true, serializer.call(this, target.call(this)), ...store_key.split("."));
+                });
+                core.on("beforeSaveArchive", () => {
+                    core.storage.setSaveableData(core.storage.archiveData, false, serializer.call(this, target.call(this)), ...store_key.split("."));
+                });
+            });
+        });
+        return function () {
+            let val = archiveStateGetterWithSerializer(this, store_key, target, serializer);
+            return val;
+        };
+    };
+}
+/**
+ * 存档属性装饰器
+ * @param store_key 保存数据到存档数据对象的key
+ * @returns
+ */
+export function SaveSetter(store_key) {
+    return (target, context) => {
+        if (context.kind !== "setter") {
+            throw new Error("ArchiveStateSetter只能用于setter属性");
+        }
+        context.addInitializer(function () {
+            Async.nextTick(() => {
+                let core = this._core;
+                core.on("afterLoadArchive", () => {
+                    let dataInArchive = core.storage.getSaveableData(core.storage.archiveData, false, ...store_key.split("."));
+                    this._core.debug.log(`Load Data from Archive, store_key: ${store_key}, dataInArchive: ${JSON.stringify(dataInArchive)}`);
+                    target.call(this, dataInArchive);
+                });
+            });
+        });
+        return function (value) {
+            archiveStateSetter(this, store_key, target, value);
+        };
+    };
+}
+export function CustomSaveSetter(store_key, deserializer) {
+    return (target, context) => {
+        if (context.kind !== "setter") {
+            throw new Error("ArchiveStateSetter只能用于setter属性");
+        }
+        context.addInitializer(function () {
+            Async.nextTick(() => {
+                let core = this._core;
+                core.on("afterLoadArchive", () => {
+                    let dataInArchive = core.storage.getSaveableData(core.storage.archiveData, false, ...store_key.split("."));
+                    this._core.debug.log(`Load Data from Archive, store_key: ${store_key}, dataInArchive: ${JSON.stringify(dataInArchive)}`);
+                    target.call(this, deserializer.call(this, dataInArchive));
+                });
+            });
+        });
+        return function (value) {
+            archiveStateSetterWithDeserializer(this, store_key, target, value, deserializer);
+        };
+    };
+}
+/**
+ * 存档属性装饰器
+ * @param store_key 保存数据到存档数据对象的key
+ * @returns
+ */
+function archiveStateGetter(_this, store_key, old_getter) {
+    const core = _this._core;
+    // if (!core.storage._archiveStateGetterRegisteredList.has(store_key)) {
+    //   core.storage._archiveStateGetterRegisteredList.add(store_key);
+    //   core.on("initArchiveData", () => {
+    //     core.storage.setSaveableData(
+    //       core.storage.archiveData,
+    //       true,
+    //       old_getter.call(_this),
+    //       ...store_key.split(".")
+    //     );
+    //   });
+    //   core.on("beforeSaveArchive", () => {
+    //     core.storage.setSaveableData(
+    //       core.storage.archiveData,
+    //       false,
+    //       old_getter.call(_this),
+    //       ...store_key.split(".")
+    //     );
+    //   });
+    // }
+    let val = old_getter.call(_this);
+    // console.log(`getval: ${val}`);
+    return val;
+}
+/**
+ * 存档属性装饰器
+ * @param store_key 保存数据到存档数据对象的key
+ * @returns
+ */
+function archiveStateGetterWithSerializer(_this, store_key, old_getter, serializer) {
+    const core = _this._core;
+    // if (!core.storage._archiveStateGetterRegisteredList.has(store_key)) {
+    //   core.storage._archiveStateGetterRegisteredList.add(store_key);
+    //   core.on("initArchiveData", () => {
+    //     core.storage.setSaveableData(
+    //       core.storage.archiveData,
+    //       true,
+    //       serializer.call(_this, old_getter.call(_this)),
+    //       ...store_key.split(".")
+    //     );
+    //   });
+    //   core.on("beforeSaveArchive", () => {
+    //     core.storage.setSaveableData(
+    //       core.storage.archiveData,
+    //       false,
+    //       serializer.call(_this, old_getter.call(_this)),
+    //       ...store_key.split(".")
+    //     );
+    //   });
+    // }
+    let val = old_getter.call(_this);
+    // console.log(`getval: ${val}`);
+    return val;
+}
+function archiveStateSetter(_this, store_key, old_setter, val) {
+    // const core = _this._core;
+    // if (!core.storage._archiveStateSetterRegisteredList.has(store_key)) {
+    //   core.storage._archiveStateSetterRegisteredList.add(store_key);
+    //   core.on("afterLoadArchive", () => {
+    //     let dataInArchive = core.storage.getSaveableData(
+    //       core.storage.archiveData,
+    //       false,
+    //       ...store_key.split(".")
+    //     ) as Value;
+    //     console.log(`Load Data from Archive, store_key: ${store_key}`);
+    //     old_setter.call(_this, dataInArchive);
+    //   });
+    // }
+    old_setter.call(_this, val);
+    // console.log(`setval: ${val}`);
+}
+function archiveStateSetterWithDeserializer(_this, store_key, old_setter, val, deserializer) {
+    // const core = _this._core;
+    // if (!core.storage._archiveStateSetterRegisteredList.has(store_key)) {
+    //   core.storage._archiveStateSetterRegisteredList.add(store_key);
+    //   core.on("afterLoadArchive", () => {
+    //     let dataInArchive = core.storage.getSaveableData(
+    //       core.storage.archiveData,
+    //       false,
+    //       ...store_key.split(".")
+    //     ) as SerializedValue;
+    //     console.log(`Load Data from Archive, store_key: ${store_key}`);
+    //     old_setter.call(_this, deserializer.call(_this, dataInArchive));
+    //   });
+    // }
+    old_setter.call(_this, val);
+    // console.log(`setval: ${val}`);
+}

package/dist/storage/fs.js

@@ -0,0 +1,96 @@
+// import * as hmApp from "@zos/app";
+// import * as hmFS from "@zos/fs";
+// import Path ;
+// function getAppDir(appId = (hmApp.getPackageInfo() as any).appId) {
+//   let str = appId.toString(16);
+//   switch (str.length) {
+//     case 1:
+//       return `0000000${str}`.toUpperCase();
+//     case 2:
+//       return `000000${str}`.toUpperCase();
+//     case 3:
+//       return `00000${str}`.toUpperCase();
+//     case 4:
+//       return `0000${str}`.toUpperCase();
+//     case 5:
+//       return `000${str}`.toUpperCase();
+//     case 6:
+//       return `00${str}`.toUpperCase();
+//     case 7:
+//       return `0${str}`.toUpperCase();
+//     case 8:
+//       return `${str}`.toUpperCase();
+//   }
+// }
+export {};
+// function readdirAssetsSync(option: { path: string }): string[] | undefined {
+//   return hmFS.readdirSync({
+//     path: fromDataToAssetsPath(option.path),
+//   });
+// }
+// export function isFileSync(option: { path: string }) {
+//   let code = hmFS.openSync({ path: option.path });
+//   if (code >= 0) {
+//     hmFS.closeSync({ fd: code });
+//     return true;
+//   } else {
+//     return false;
+//   }
+// }
+// function isFileAssetsSync(option: { path: string }) {
+//   // console.log("path=" + option.path);
+//   let code = hmFS.openAssetsSync({ path: option.path });
+//   if (code >= 0) {
+//     hmFS.closeSync({ fd: code });
+//     return true;
+//   } else {
+//     return false;
+//   }
+// }
+// /**
+//  * 将基于assets的文件路径转换为基于data的文件路径
+//  */
+// function fromDataToAssetsPath(path: string) {
+//   return Path.join(`../../${getAppDir()}/assets`, path);
+// }
+// function writeFileAssetsSync(opt: {
+//   path: string;
+//   data: string | ArrayBuffer | DataView;
+//   options?: hmFS.writeFileSync.Options;
+// }) {
+//   // console.log("write path="+opt.path);
+//   let fd = hmFS.openAssetsSync({
+//     path: opt.path,
+//     flag: hmFS.O_WRONLY | hmFS.O_CREAT,
+//   });
+//   if (fd < 0) throw "Open Assets File Failed code=" + fd;
+//   let buf = opt.data;
+//   if (buf instanceof DataView) {
+//     buf = buf.buffer; // TODO maybe error
+//   }
+//   if (typeof buf === "string") buf = Buffer.from(buf).buffer;
+//   let res = hmFS.writeSync({
+//     fd,
+//     buffer: buf,
+//   });
+//   hmFS.closeSync({ fd });
+//   return res;
+// }
+// function readFileAssetsSync(opt: {
+//   path: string;
+//   options?: hmFS.readFileSync.Options;
+// }) {
+//   // console.log("read path="+opt.path);
+//   let fd = hmFS.openAssetsSync({ path: opt.path, flag: hmFS.O_RDONLY });
+//   if (fd < 0) throw "Open Assets File Failed code=" + fd;
+//   let size = hmFS.statAssetsSync({ path: opt.path })!.size;
+//   let arrbuf = new ArrayBuffer(size);
+//   let res = hmFS.readSync({ fd, buffer: arrbuf });
+//   console.log("read size=" + res);
+//   hmFS.closeSync({ fd });
+//   if (opt.options && typeof opt.options.encoding === "string") {
+//     return Buffer.from(arrbuf).toString(opt.options.encoding);
+//   } else {
+//     return arrbuf;
+//   }
+// }