hzengine-core 0.1.2-dev

package/src/utils/path.js

@@ -0,0 +1,338 @@
+// path utils for ZeppOS
+// @CuberQAQ
+// Generated by GPT-4o mini
+"use strict";
+
+var util = {
+  isString: (x) => typeof x === "string", // 检查是否为字符串
+  isObject: (x) => typeof x === "object", // 检查是否为对象
+};
+
+/**
+ * 检查路径是否包含协议
+ * @param {string} path - 路径字符串
+ * @returns {boolean} - 如果路径包含协议，则返回 true
+ */
+function isProtocolPath(path) {
+  return /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(path);
+}
+
+/**
+ * 提取协议和路径部分
+ * @param {string} path - 路径字符串
+ * @returns {{protocol: string, filepath: string}} - 包含协议和文件路径的对象
+ */
+function extractProtocol(path) {
+  const match = path.match(/^([a-zA-Z][a-zA-Z\d+\-.]*):\/\/(.*)$/);
+  if (match) {
+    return {
+      protocol: match[1], // 获取协议
+      filepath: match[2], // 获取文件路径
+    };
+  }
+  return { protocol: null, filepath: path }; // 如果没有协议，返回原路径
+}
+
+/**
+ * 解析路径数组并规范化
+ * @param {string[]} parts - 路径组成部分
+ * @param {boolean} allowAboveRoot - 是否允许上级目录
+ * @returns {string[]} - 规范化后的路径部分
+ */
+function normalizeArray(parts, allowAboveRoot) {
+  var res = [];
+  for (var i = 0; i < parts.length; i++) {
+    var p = parts[i];
+
+    // 忽略空部分和当前目录（.）
+    if (!p || p === ".") continue;
+
+    // 处理上级目录（..）
+    if (p === "..") {
+      if (res.length && res[res.length - 1] !== "..") {
+        res.pop(); // 移除最后一个部分
+      } else if (allowAboveRoot) {
+        res.push(".."); // 允许上级目录
+      }
+    } else {
+      res.push(p); // 添加有效部分
+    }
+  }
+
+  return res;
+}
+
+/**
+ * 移除数组两端的空元素
+ * @param {string[]} arr - 输入数组
+ * @returns {string[]} - 去除空元素后的数组
+ */
+function trimArray(arr) {
+  var lastIndex = arr.length - 1;
+  var start = 0;
+  for (; start <= lastIndex; start++) {
+    if (arr[start]) break;
+  }
+
+  var end = lastIndex;
+  for (; end >= 0; end--) {
+    if (arr[end]) break;
+  }
+
+  if (start === 0 && end === lastIndex) return arr;
+  if (start > end) return [];
+  return arr.slice(start, end + 1);
+}
+
+// 使用正则表达式分割路径
+var splitPathRe =
+  /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
+var posix = {};
+
+/**
+ * 分割路径
+ * @param {string} filename - 输入的路径字符串
+ * @returns {string[]} - 分割后的路径组成部分
+ */
+function posixSplitPath(filename) {
+  return splitPathRe.exec(filename).slice(1);
+}
+
+/**
+ * 解析路径，将相对路径转换为绝对路径
+ * @param {...string} paths - 要解析的路径
+ * @returns {string} - 解析后的绝对路径
+ */
+posix.resolve = function () {
+  var resolvedPath = "",
+    resolvedAbsolute = false;
+
+  for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+    var path = i >= 0 ? arguments[i] : process.cwd();
+
+    // 跳过空和无效的条目
+    if (!util.isString(path)) {
+      throw new TypeError("Arguments to path.resolve must be strings");
+    } else if (!path) {
+      continue;
+    }
+
+    // 检查路径是否包含协议
+    if (isProtocolPath(path)) {
+      const { protocol, filepath } = extractProtocol(path);
+      resolvedPath = filepath + "/" + resolvedPath;
+      resolvedAbsolute = true; // 将协议路径视为绝对路径
+    } else {
+      resolvedPath = path + "/" + resolvedPath;
+      resolvedAbsolute = path[0] === "/";
+    }
+  }
+
+  // 规范化路径
+  resolvedPath = normalizeArray(
+    resolvedPath.split("/"),
+    !resolvedAbsolute
+  ).join("/");
+
+  return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
+};
+
+/**
+ * 规范化路径，去除多余的斜杠和当前目录
+ * @param {string} path - 输入的路径字符串
+ * @returns {string} - 规范化后的路径
+ */
+posix.normalize = function (path) {
+  // 检查路径是否包含协议
+  if (isProtocolPath(path)) {
+    const { protocol, filepath } = extractProtocol(path);
+    return protocol + "://" + normalizeArray(filepath.split("/")).join("/");
+  }
+
+  var isAbsolute = posix.isAbsolute(path),
+    trailingSlash = path && path[path.length - 1] === "/";
+
+  // 规范化路径
+  path = normalizeArray(path.split("/"), !isAbsolute).join("/");
+
+  if (!path && !isAbsolute) {
+    path = ".";
+  }
+  if (path && trailingSlash) {
+    path += "/";
+  }
+
+  return (isAbsolute ? "/" : "") + path;
+};
+
+/**
+ * 检查路径是否为绝对路径
+ * @param {string} path - 输入的路径字符串
+ * @returns {boolean} - 如果路径为绝对路径，则返回 true
+ */
+posix.isAbsolute = function (path) {
+  return path.charAt(0) === "/";
+};
+
+/**
+ * 连接多个路径段为一个路径
+ * @param {...string} segments - 要连接的路径段
+ * @returns {string} - 连接后的路径
+ */
+posix.join = function () {
+  var path = "";
+  for (var i = 0; i < arguments.length; i++) {
+    var segment = arguments[i];
+    if (!util.isString(segment)) {
+      throw new TypeError("Arguments to path.join must be strings");
+    }
+    if (segment) {
+      if (!path) {
+        path += segment;
+      } else {
+        path += "/" + segment;
+      }
+    }
+  }
+  return posix.normalize(path);
+};
+
+/**
+ * 计算相对路径
+ * @param {string} from - 起始路径
+ * @param {string} to - 目标路径
+ * @returns {string} - 相对路径
+ */
+posix.relative = function (from, to) {
+  from = posix.resolve(from).substr(1);
+  to = posix.resolve(to).substr(1);
+
+  var fromParts = trimArray(from.split("/"));
+  var toParts = trimArray(to.split("/"));
+
+  var length = Math.min(fromParts.length, toParts.length);
+  var samePartsLength = length;
+  for (var i = 0; i < length; i++) {
+    if (fromParts[i] !== toParts[i]) {
+      samePartsLength = i;
+      break;
+    }
+  }
+
+  var outputParts = [];
+  for (var i = samePartsLength; i < fromParts.length; i++) {
+    outputParts.push("..");
+  }
+
+  outputParts = outputParts.concat(toParts.slice(samePartsLength));
+
+  return outputParts.join("/");
+};
+
+/**
+ * 获取路径的目录名
+ * @param {string} path - 输入的路径字符串
+ * @returns {string} - 目录名
+ */
+posix.dirname = function (path) {
+  var result = posixSplitPath(path),
+    root = result[0],
+    dir = result[1];
+
+  if (!root && !dir) {
+    return ".";
+  }
+
+  if (dir) {
+    dir = dir.substr(0, dir.length - 1); // 去掉尾部斜杠
+  }
+
+  return root + dir;
+};
+
+/**
+ * 获取路径的基本名
+ * @param {string} path - 输入的路径字符串
+ * @param {string} [ext] - 可选的扩展名，如果提供则将其从基本名中去除
+ * @returns {string} - 基本名
+ */
+posix.basename = function (path, ext) {
+  var f = posixSplitPath(path)[2];
+  if (ext && f.substr(-1 * ext.length) === ext) {
+    f = f.substr(0, f.length - ext.length);
+  }
+  return f;
+};
+
+/**
+ * 获取路径的扩展名
+ * @param {string} path - 输入的路径字符串
+ * @returns {string} - 扩展名
+ */
+posix.extname = function (path) {
+  return posixSplitPath(path)[3];
+};
+
+/**
+ * 格式化路径对象为路径字符串
+ * @param {Object} pathObject - 路径对象
+ * @param {string} pathObject.root - 根路径
+ * @param {string} pathObject.dir - 目录路径
+ * @param {string} pathObject.base - 基本文件名
+ * @param {string} pathObject.ext - 扩展名
+ * @param {string} pathObject.name - 文件名（不包含扩展名）
+ * @returns {string} - 格式化后的路径字符串
+ */
+posix.format = function (pathObject) {
+  if (!util.isObject(pathObject)) {
+    throw new TypeError(
+      "Parameter 'pathObject' must be an object, not " + typeof pathObject
+    );
+  }
+
+  var root = pathObject.root || "";
+
+  if (!util.isString(root)) {
+    throw new TypeError(
+      "'pathObject.root' must be a string or undefined, not " +
+        typeof pathObject.root
+    );
+  }
+
+  var dir = pathObject.dir ? pathObject.dir + posix.sep : "";
+  var base = pathObject.base || "";
+  return dir + base;
+};
+
+/**
+ * 解析路径字符串为路径对象
+ * @param {string} pathString - 输入的路径字符串
+ * @returns {{root: string, dir: string, base: string, ext: string, name: string}} - 路径对象
+ */
+posix.parse = function (pathString) {
+  if (!util.isString(pathString)) {
+    throw new TypeError(
+      "Parameter 'pathString' must be a string, not " + typeof pathString
+    );
+  }
+  var allParts = posixSplitPath(pathString);
+  if (!allParts || allParts.length !== 4) {
+    throw new TypeError("Invalid path '" + pathString + "'");
+  }
+  allParts[1] = allParts[1] || "";
+  allParts[2] = allParts[2] || "";
+  allParts[3] = allParts[3] || "";
+
+  return {
+    root: allParts[0],
+    dir: allParts[0] + allParts[1].slice(0, -1),
+    base: allParts[2],
+    ext: allParts[3],
+    name: allParts[2].slice(0, allParts[2].length - allParts[3].length),
+  };
+};
+
+posix.sep = "/"; // POSIX 路径分隔符
+posix.delimiter = ":"; // POSIX 路径分隔符（用于环境变量）
+
+export default posix; // 导出 posix 模块

package/tsconfig.json

@@ -0,0 +1,111 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig to read more about this file */
+
+    /* Projects */
+    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
+    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
+    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
+    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
+    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
+    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
+
+    /* Language and Environment */
+    "target": "ES6",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
+    // "experimentalDecorators": true,                   /* Enable experimental support for legacy experimental decorators. */
+    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
+    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
+    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
+    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
+    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
+    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
+    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
+    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
+
+    /* Modules */
+    "module": "NodeNext",                                /* Specify what module code is generated. */
+    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
+    // "moduleResolution": "node10",                     /* Specify how TypeScript looks up a file from a given module specifier. */
+    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
+    "paths": {
+    },                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
+    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
+    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
+    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
+    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
+    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
+    // "allowImportingTsExtensions": true,               /* Allow imports to include TypeScript file extensions. Requires '--moduleResolution bundler' and either '--noEmit' or '--emitDeclarationOnly' to be set. */
+    // "resolvePackageJsonExports": true,                /* Use the package.json 'exports' field when resolving package imports. */
+    // "resolvePackageJsonImports": true,                /* Use the package.json 'imports' field when resolving imports. */
+    // "customConditions": [],                           /* Conditions to set in addition to the resolver-specific defaults when resolving imports. */
+    // "resolveJsonModule": true,                        /* Enable importing .json files. */
+    // "allowArbitraryExtensions": true,                 /* Enable importing files with any extension, provided a declaration file is present. */
+    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
+
+    /* JavaScript Support */
+    "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
+    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
+    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
+
+    /* Emit */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    "outDir": "./dist",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    "declarationDir": "./types",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
+    // "verbatimModuleSyntax": true,                     /* Do not transform or elide any imports or exports not marked as type-only, ensuring they are written in the output file's format based on the 'module' setting. */
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
+
+    /* Type Checking */
+    "strict": true,                                      /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
+  },
+  "include": ["./src", "../hzengine-0.2-launcher/shared/zos_media.d.ts"]
+}

package/types/async/index.d.ts

@@ -0,0 +1,24 @@
+import { HZEngineCore, Storage } from "../index.js";
+export declare class Async {
+    _core: HZEngineCore;
+    static _nextTickCallbacks: (() => void)[];
+    static _nextTickTimerId: number | null;
+    static nextTick(callback: () => void): void;
+    static _nextTickTimerCallback(): void;
+    private _lastTime;
+    constructor(_core: HZEngineCore);
+    _scheduleTask(): void;
+    private accessor _nextTimerId;
+    private accessor _delayTasks;
+    addDelayTask(event: string, args: Storage.Saveable<unknown>[], delayMs: number): number;
+    addRepeatTask(event: string, args: Storage.Saveable<unknown>[], intervalMs: number, delayMs?: number): number;
+    removeTask(id: number): void;
+}
+export declare namespace Async {
+    interface Task {
+        event: string;
+        args: Storage.Saveable<unknown>[];
+        next: number;
+        repeat: number;
+    }
+}

package/types/async/zeppos_timer.d.ts

@@ -0,0 +1,14 @@
+export class ZeppTimer {
+    constructor(callback: any, interval: any);
+    callback: any;
+    interval: any;
+    timerId: any;
+    startTime: any;
+    nextTick: any;
+    time: any;
+    stopped: boolean;
+    start(delay?: number): void;
+    stop(): void;
+    scheduleTick(): void;
+    tick(): void;
+}

package/types/audio/index.d.ts

@@ -0,0 +1,64 @@
+import { HZEngineCore } from "../index.js";
+import { Platform } from "../platform/index.js";
+export declare class Audio {
+    _core: HZEngineCore;
+    constructor(_core: HZEngineCore);
+    private accessor _channels;
+    get channels(): Record<string, Audio.Channel>;
+    createChannel(name: string): Audio.Channel;
+}
+export declare namespace Audio {
+    class Channel {
+        _audio: Audio;
+        _audioPlayer: Platform.AudioPlayer;
+        constructor(_audio: Audio);
+        onRelease(): void;
+        mode: Channel.Mode;
+        status: Channel.Status;
+        _playbackList: PlaybackItem[];
+        _nowIndex: number | null;
+        currentInfo: AudioInfo | null;
+        push(item: PlaybackItem): void;
+        play(): void;
+        pause(): void;
+        /**
+         * 停止并清空队列
+         */
+        stop(): void;
+        serialize(): Channel.Serialized;
+        static deserialize(audio: Audio, data: Channel.Serialized): Channel;
+        _onPrepared(result: boolean): void;
+        _onCompleted(): void;
+        /**
+         * Play the next item in the playback list. If there are no items in the
+         * playback list, set the channel status to Stopped and return.
+         * @private
+         */
+        _playNext(): void;
+    }
+    namespace Channel {
+        enum Mode {
+            PlayInOrder = 0,
+            PlayInOrderRepeat = 1
+        }
+        enum Status {
+            Stopped = 0,
+            Playing = 1,
+            Error = 2
+        }
+        type Serialized = {
+            mode: Channel.Mode;
+            status: Channel.Status;
+            playbackList: PlaybackItem[];
+            nowIndex: number | null;
+        };
+    }
+    interface PlaybackItem {
+        path: string;
+    }
+    interface AudioInfo {
+        duration: number;
+        title: string;
+        artist: string;
+    }
+}

package/types/config/index.d.ts

@@ -0,0 +1,9 @@
+import { HZEngineCore } from "../index.js";
+export declare class Config {
+    private _core;
+    constructor(_core: HZEngineCore);
+    getConfig(key: string): NonNullable<import("../index.js").Storage.JSONValue> | undefined;
+    setConfig(key: string, value: any): void;
+    private normalizeKey;
+    resetConfig(): void;
+}

package/types/debug/index.d.ts

@@ -0,0 +1,6 @@
+import { HZEngineCore } from "../index.js";
+export declare class Debug {
+    private _core;
+    constructor(_core: HZEngineCore);
+    log(...args: any[]): void;
+}

package/types/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * HZEngineCore
+ * @copyright Copyright (c) 2024 CuberQAQ. All rights reserved.
+ */
+import { Async } from "./async/index.js";
+import { Audio } from "./audio/index.js";
+import { Config } from "./config/index.js";
+import { Debug } from "./debug/index.js";
+import Platform from "./platform/index.js";
+import { Script } from "./script/index.js";
+import { Storage } from "./storage/index.js";
+import { System } from "./system/index.js";
+import { UI } from "./ui/index.js";
+declare class HZEngineCore<PlatformType extends Platform = any> {
+    platform: PlatformType;
+    private _eventCallbacks;
+    storage: Storage;
+    async: Async;
+    ui: UI<PlatformType>;
+    script: Script;
+    system: System<PlatformType>;
+    config: Config;
+    audio: Audio;
+    debug: Debug;
+    constructor(platform: PlatformType);
+    loadProject(options: {
+        projectPath: string;
+        cachePath: string;
+        savePath: string;
+    }): void;
+    start(callback?: () => unknown): void;
+    end(): void;
+    plugins: Map<string, unknown>;
+    loadPlugin(name: string, plugin: Plugin<PlatformType>): void;
+    on(event: string, cb: Function): void;
+    off(event: string, cb: Function): boolean;
+    emit(event: string, ...args: any[]): void;
+}
+type Plugin<PlatformType extends Platform> = (core: HZEngineCore<PlatformType>) => any;
+export { HZEngineCore, UI, Storage, Script, System, Async, type Platform };
+export * as TransformPlugin from "./plugins/transform/index.js";