@eventusgo/vite-plugin 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import { Plugin } from 'vite';
+
+declare const EVENTUS_MANIFEST_FILE = "eventus.manifest.json";
+declare const EVENTUS_VIRTUAL_MANIFEST_ID = "virtual:eventus-manifest";
+declare const EVENTUS_RESOLVED_VIRTUAL_MANIFEST_ID = "\0virtual:eventus-manifest";
+declare const EVENTUS_APP_ID_PATTERN: RegExp;
+type EventusVitePluginOptions = {
+    manifestPath?: string;
+};
+type EventusManifest = {
+    name: string;
+    appId: string;
+    version: string;
+    permissions?: string[];
+};
+declare class EventusManifestError extends Error {
+    constructor(message: string);
+}
+declare function resolveManifestPath(root: string, manifestPath?: string): string;
+declare function readEventusManifest(root: string, manifestPath?: string): {
+    filePath: string;
+    manifest: EventusManifest;
+};
+declare function validateEventusManifest(value: unknown, filePath?: string): EventusManifest;
+declare function eventusVitePlugin(options?: EventusVitePluginOptions): Plugin;
+
+export { EVENTUS_APP_ID_PATTERN, EVENTUS_MANIFEST_FILE, EVENTUS_RESOLVED_VIRTUAL_MANIFEST_ID, EVENTUS_VIRTUAL_MANIFEST_ID, type EventusManifest, EventusManifestError, type EventusVitePluginOptions, eventusVitePlugin, readEventusManifest, resolveManifestPath, validateEventusManifest };

package/dist/index.js

@@ -0,0 +1,150 @@
+// src/index.ts
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+var EVENTUS_MANIFEST_FILE = "eventus.manifest.json";
+var EVENTUS_VIRTUAL_MANIFEST_ID = "virtual:eventus-manifest";
+var EVENTUS_RESOLVED_VIRTUAL_MANIFEST_ID = "\0virtual:eventus-manifest";
+var EVENTUS_APP_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var EventusManifestError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EventusManifestError";
+  }
+};
+function resolveManifestPath(root, manifestPath) {
+  return path.resolve(root, manifestPath ?? EVENTUS_MANIFEST_FILE);
+}
+function readEventusManifest(root, manifestPath) {
+  const filePath = resolveManifestPath(root, manifestPath);
+  if (!existsSync(filePath)) {
+    throw new EventusManifestError(
+      `Missing Eventus manifest: expected ${path.basename(filePath)} at ${filePath}.`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(filePath, "utf8"));
+  } catch (error) {
+    throw new EventusManifestError(
+      `Invalid JSON in ${filePath}: ${error.message}`
+    );
+  }
+  return {
+    filePath,
+    manifest: validateEventusManifest(parsed, filePath)
+  };
+}
+function validateEventusManifest(value, filePath = EVENTUS_MANIFEST_FILE) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new EventusManifestError(
+      `Invalid Eventus manifest in ${filePath}: expected a JSON object.`
+    );
+  }
+  const manifest = value;
+  const name = readRequiredString(manifest, "name", filePath);
+  const appId = readRequiredString(manifest, "appId", filePath);
+  const version = readRequiredString(manifest, "version", filePath);
+  if (!EVENTUS_APP_ID_PATTERN.test(appId)) {
+    throw new EventusManifestError(
+      `Invalid Eventus manifest in ${filePath}: "appId" must use lowercase letters, numbers, and hyphens.`
+    );
+  }
+  const permissions = manifest.permissions;
+  if (permissions !== void 0 && (!Array.isArray(permissions) || permissions.some((permission) => typeof permission !== "string"))) {
+    throw new EventusManifestError(
+      `Invalid Eventus manifest in ${filePath}: "permissions" must be an array of strings.`
+    );
+  }
+  return {
+    name,
+    appId,
+    version,
+    ...permissions ? { permissions } : {}
+  };
+}
+function readRequiredString(manifest, key, filePath) {
+  const value = manifest[key];
+  if (typeof value !== "string" || !value.trim()) {
+    throw new EventusManifestError(
+      `Invalid Eventus manifest in ${filePath}: "${key}" is required and must be a non-empty string.`
+    );
+  }
+  return value;
+}
+function eventusVitePlugin(options = {}) {
+  let rootDir = process.cwd();
+  let manifestFile = resolveManifestPath(rootDir, options.manifestPath);
+  let manifest;
+  const loadManifest = () => {
+    const result = readEventusManifest(rootDir, options.manifestPath);
+    manifestFile = result.filePath;
+    manifest = result.manifest;
+    return result.manifest;
+  };
+  const createManifestInjectionTag = () => ({
+    tag: "script",
+    attrs: {
+      type: "application/javascript"
+    },
+    injectTo: "head",
+    children: `globalThis.__EVENTUS_MANIFEST__ = ${JSON.stringify(
+      manifest ?? loadManifest()
+    )};`
+  });
+  return {
+    name: "eventus:vite-plugin",
+    enforce: "pre",
+    configResolved(config) {
+      rootDir = config.root;
+      loadManifest();
+    },
+    buildStart() {
+      loadManifest();
+    },
+    resolveId(id) {
+      if (id === EVENTUS_VIRTUAL_MANIFEST_ID) {
+        return EVENTUS_RESOLVED_VIRTUAL_MANIFEST_ID;
+      }
+      return void 0;
+    },
+    load(id) {
+      if (id === EVENTUS_RESOLVED_VIRTUAL_MANIFEST_ID) {
+        return `export default ${JSON.stringify(manifest ?? loadManifest(), null, 2)};`;
+      }
+      return void 0;
+    },
+    transformIndexHtml() {
+      return [createManifestInjectionTag()];
+    },
+    handleHotUpdate(context) {
+      if (path.resolve(context.file) !== manifestFile) {
+        return;
+      }
+      try {
+        loadManifest();
+        const module = context.server.moduleGraph.getModuleById(
+          EVENTUS_RESOLVED_VIRTUAL_MANIFEST_ID
+        );
+        if (module) {
+          context.server.moduleGraph.invalidateModule(module);
+        }
+        context.server.ws.send({ type: "full-reload" });
+      } catch (error) {
+        manifest = void 0;
+        context.server.config.logger.error(error.message);
+      }
+      return [];
+    }
+  };
+}
+export {
+  EVENTUS_APP_ID_PATTERN,
+  EVENTUS_MANIFEST_FILE,
+  EVENTUS_RESOLVED_VIRTUAL_MANIFEST_ID,
+  EVENTUS_VIRTUAL_MANIFEST_ID,
+  EventusManifestError,
+  eventusVitePlugin,
+  readEventusManifest,
+  resolveManifestPath,
+  validateEventusManifest
+};

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@eventusgo/vite-plugin",
+  "version": "0.1.0",
+  "description": "Vite plugin for Eventus mini-app manifests.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./src/client.d.ts",
+      "import": "./dist/client.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/client.d.ts"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "vite": "^5.0.0"
+  }
+}

package/src/client.d.ts

@@ -0,0 +1,17 @@
+type EventusManifest = {
+  name: string;
+  appId: string;
+  version: string;
+  permissions?: string[];
+};
+
+declare module "virtual:eventus-manifest" {
+  const manifest: EventusManifest;
+  export default manifest;
+}
+
+declare global {
+  const __EVENTUS_MANIFEST__: EventusManifest;
+}
+
+export {};