@vnejs/core 0.2.11 → 0.2.12

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "@vnejs/core",
-  "version": "0.2.11",
+  "version": "0.2.12",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "src",
+    "tsconfig.json"
   ],
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "rm -rf dist && tsc -p tsconfig.json",
-    "publish:major": "npm run build && npm version major && npm publish --access public",
-    "publish:minor": "npm run build && npm version minor && npm publish --access public",
-    "publish:patch": "npm run build && npm version patch && npm publish --access public"
+    "build": "npx @vnejs/monorepo package",
+    "publish:major": "npx @vnejs/monorepo publish major --access public",
+    "publish:minor": "npx @vnejs/monorepo publish minor --access public",
+    "publish:patch": "npx @vnejs/monorepo publish patch --access public"
   },
   "author": "",
   "license": "ISC",
@@ -33,8 +35,5 @@
     "@vnejs/module.components": "~0.0.1",
     "@vnejs/observer": "~0.0.1",
     "@vnejs/helpers": "~0.1.0"
-  },
-  "devDependencies": {
-    "typescript": "^6.0.3"
   }
 }

package/src/index.ts

@@ -0,0 +1,69 @@
+import { Observer } from "@vnejs/observer";
+import { Module, type ModuleGlobalStateRegistry, type ModuleInject } from "@vnejs/module";
+import { VNE, VNE_MODULES } from "@vnejs/shared";
+import type { VneModuleClass } from "@vnejs/shared";
+import { toJson } from "@vnejs/helpers";
+
+import type { CoreVnePluginConstantsMap, CoreVnePluginEventsMap, ModuleMedia, ModuleShared, VneCoreModules } from "./types.js";
+import { mergeFetchResult } from "./utils.js";
+
+export type { ModuleMedia, ModuleShared, VneCoreModules } from "./types.js";
+
+export class VneCore {
+  observer = new Observer();
+  modules: VneCoreModules = {};
+  state: ModuleGlobalStateRegistry = {};
+  shared: ModuleShared = {};
+
+  constructor() {
+    VNE_MODULES.forEach(this.addModule);
+  }
+
+  init = async () => {
+    const CONST = VNE.CONST as unknown as CoreVnePluginConstantsMap;
+    const ts = Math.round(new Date().getTime() / 1000 / 60 / 60);
+
+    const mods = (await fetch(`${CONST.SYSTEM.HOST}/mods.json?ts=${ts}`).then(toJson)) as string[];
+    const fetchResult = await Promise.all(mods.map((mod) => fetch(`${CONST.SYSTEM.HOST}/media.${mod}.json?ts=${ts}`).then(toJson) as Promise<ModuleMedia>));
+    const media = fetchResult.reduce(mergeFetchResult, {} as ModuleMedia);
+    const injectArg: ModuleInject = { observer: this.observer, state: this.state, shared: this.shared, media };
+
+    Object.values(this.modules).forEach((module) => {
+      module?.inject(injectArg);
+      module?.subscribe();
+    });
+
+    window.uninitedModules = [];
+
+    console.log("init modules start");
+    await Promise.all(
+      Object.values(this.modules).map(async (module) => {
+        if (!module) return;
+        window.uninitedModules.push(module.name);
+        console.log("init module", module.name, "start");
+        module.isReady = false;
+        if (module.init) await module.init();
+        module.isReady = true;
+        console.log("init module", module.name, "finish");
+        window.uninitedModules = window.uninitedModules.filter((k) => k !== module.name);
+      }),
+    );
+    console.log("init modules finish");
+
+    const started = VNE.EVENTS.SYSTEM?.STARTED;
+    if (started) await this.observer.emit(started);
+  };
+
+  reset = async () => {
+    const EVENTS = VNE.EVENTS as unknown as CoreVnePluginEventsMap;
+
+    await this.observer.emit(EVENTS.STORAGE.CLEAR);
+    await this.observer.emit(EVENTS.SYSTEM.RELOAD);
+  };
+
+  addModule = (ModuleClass: VneModuleClass) => {
+    const module = new ModuleClass() as Module;
+
+    this.modules[module.name] = module;
+  };
+}

package/src/types.ts

@@ -0,0 +1,20 @@
+import type { Module, ModuleMedia, ModuleShared } from "@vnejs/module";
+
+export type VneCoreModules = Record<string, Module | undefined>;
+
+export type { ModuleMedia, ModuleShared };
+
+declare global {
+  interface Window {
+    uninitedModules: string[];
+  }
+}
+
+export interface CoreVnePluginEventsMap {
+  STORAGE: { CLEAR: string };
+  SYSTEM: { RELOAD: string; STARTED: string; HOST: string };
+}
+
+export interface CoreVnePluginConstantsMap {
+  SYSTEM: { HOST: string };
+}

package/src/utils.ts

@@ -0,0 +1,10 @@
+import type { ModuleMedia } from "./types.js";
+
+export const mergeFetchResult = (acc: ModuleMedia, media: ModuleMedia) => {
+  Object.keys(media).forEach((key) => {
+    if (!acc[key]) acc[key] = {};
+    Object.assign(acc[key], media[key]);
+  });
+
+  return acc;
+};

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022", "DOM"],
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "noEmitOnError": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "node_modules"]
+}