@holo-js/events 0.1.4 → 0.1.6

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { QueueJobDefinition, QueueJsonValue } from '@holo-js/queue';
 
 type EventDelayValue = number | Date;
-declare function normalizeOptionalString(value: string | undefined, label: string): string | undefined;
+declare function normalizeOptionalString(value: unknown, label: string): string | undefined;
 declare function normalizeOptionalBoolean(value: boolean | undefined, label: string): boolean | undefined;
 declare function normalizeOptionalDelay(value: EventDelayValue | undefined): EventDelayValue | undefined;
 declare function toPosixPath(value: string): string;
@@ -9,6 +9,7 @@ declare function deriveEventNameFromSourcePath(sourcePath: string): string;
 declare function isReadonlyArray(value: unknown): value is readonly unknown[];
 declare function hasEventDefinitionMarker(value: unknown): boolean;
 declare function hasListenerDefinitionMarker(value: unknown): boolean;
+declare function isPlainObject$1(value: unknown): value is Record<string, unknown>;
 interface EventDefinition<TPayload = unknown, TName extends string | undefined = string | undefined> {
     readonly name?: TName;
     readonly __payloadType?: TPayload;
@@ -115,6 +116,7 @@ declare function defineListener<TInput extends EventReferenceInput, TResult>(lis
 declare const eventInternals: {
     hasEventDefinitionMarker: typeof hasEventDefinitionMarker;
     hasListenerDefinitionMarker: typeof hasListenerDefinitionMarker;
+    isPlainObject: typeof isPlainObject$1;
     isReadonlyArray: typeof isReadonlyArray;
     deriveEventNameFromSourcePath: typeof deriveEventNameFromSourcePath;
     normalizeEventDefinition: typeof normalizeEventDefinition;

package/dist/index.mjs

@@ -5,6 +5,9 @@ function normalizeOptionalString(value, label) {
   if (typeof value === "undefined") {
     return void 0;
   }
+  if (typeof value !== "string") {
+    throw new Error(`[Holo Events] ${label} must be a non-empty string when provided.`);
+  }
   const normalized = value.trim();
   if (!normalized) {
     throw new Error(`[Holo Events] ${label} must be a non-empty string when provided.`);
@@ -57,8 +60,15 @@ function hasEventDefinitionMarker(value) {
 function hasListenerDefinitionMarker(value) {
   return !!value && typeof value === "object" && HOLO_LISTENER_DEFINITION_MARKER in value;
 }
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
 function isEventDefinition(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
+  return isPlainObject(value);
 }
 function normalizeEventDefinition(event) {
   if (!isEventDefinition(event)) {
@@ -140,6 +150,7 @@ function defineListener(listener) {
 var eventInternals = {
   hasEventDefinitionMarker,
   hasListenerDefinitionMarker,
+  isPlainObject,
   isReadonlyArray,
   deriveEventNameFromSourcePath,
   normalizeEventDefinition,
@@ -173,30 +184,30 @@ function deriveListenerIdFromSourcePath(sourcePath) {
   return derived;
 }
 function resolveRegisteredEventName(definition, options = {}) {
-  const explicitOption = options.name?.trim();
+  const explicitOption = eventInternals.normalizeOptionalString(options.name, "Event registration name");
   if (explicitOption) {
     return explicitOption;
   }
-  const explicitDefinition = definition.name?.trim();
+  const explicitDefinition = eventInternals.normalizeOptionalString(definition.name, "Event name");
   if (explicitDefinition) {
     return explicitDefinition;
   }
-  const sourcePath = options.sourcePath?.trim();
+  const sourcePath = eventInternals.normalizeOptionalString(options.sourcePath, "Event source path");
   if (sourcePath) {
     return eventInternals.deriveEventNameFromSourcePath(sourcePath);
   }
   throw new Error("[Holo Events] Registered events require an explicit name or a sourcePath-derived name.");
 }
 function resolveRegisteredListenerId(definition, options = {}) {
-  const explicitOption = options.id?.trim();
+  const explicitOption = eventInternals.normalizeOptionalString(options.id, "Listener id");
   if (explicitOption) {
     return explicitOption;
   }
-  const explicitDefinition = definition.name?.trim();
+  const explicitDefinition = eventInternals.normalizeOptionalString(definition.name, "Listener name");
   if (explicitDefinition) {
     return explicitDefinition;
   }
-  const sourcePath = options.sourcePath?.trim();
+  const sourcePath = eventInternals.normalizeOptionalString(options.sourcePath, "Listener source path");
   if (sourcePath) {
     return deriveListenerIdFromSourcePath(sourcePath);
   }
@@ -206,7 +217,7 @@ function resolveListenerEventName(reference) {
   if (typeof reference === "string") {
     return reference;
   }
-  const explicitName = reference.name?.trim();
+  const explicitName = eventInternals.normalizeOptionalString(reference.name, "Listener event reference name");
   if (explicitName) {
     return explicitName;
   }
@@ -247,13 +258,14 @@ function registerEvent(definition, options = {}) {
   }
   const normalizedDefinition = normalizeEventDefinition(definition);
   const name = resolveRegisteredEventName(normalizedDefinition, options);
+  const sourcePath = eventInternals.normalizeOptionalString(options.sourcePath, "Event source path");
   const state = getEventRegistryState();
   if (state.events.has(name) && options.replaceExisting !== true) {
     throw new Error(`[Holo Events] Event "${name}" is already registered.`);
   }
   const entry = Object.freeze({
     name,
-    ...options.sourcePath ? { sourcePath: options.sourcePath } : {},
+    ...typeof sourcePath === "undefined" ? {} : { sourcePath },
     definition: Object.freeze({
       ...normalizedDefinition,
       name
@@ -287,6 +299,7 @@ function registerListener(definition, options = {}) {
   }
   const normalizedDefinition = normalizeListenerDefinition(definition);
   const id = resolveRegisteredListenerId(normalizedDefinition, options);
+  const sourcePath = eventInternals.normalizeOptionalString(options.sourcePath, "Listener source path");
   const state = getEventRegistryState();
   if (state.listeners.has(id) && options.replaceExisting !== true) {
     throw new Error(`[Holo Events] Listener "${id}" is already registered.`);
@@ -298,7 +311,7 @@ function registerListener(definition, options = {}) {
   }
   const listener = Object.freeze({
     id,
-    ...options.sourcePath ? { sourcePath: options.sourcePath } : {},
+    ...typeof sourcePath === "undefined" ? {} : { sourcePath },
     eventNames,
     definition: Object.freeze({
       ...normalizedDefinition,
@@ -467,7 +480,7 @@ var eventQueueInternals = {
 };
 
 // src/runtime.ts
-function isPlainObject(value) {
+function isPlainObject2(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     return false;
   }
@@ -498,7 +511,7 @@ function assertEventJsonValue(value, path, state) {
     state.seen.delete(value);
     return;
   }
-  if (!isPlainObject(value)) {
+  if (!isPlainObject2(value)) {
     throw new TypeError(`[Holo Events] Event payload at "${path}" must be a plain JSON object, array, or primitive for queued listeners.`);
   }
   if (state.seen.has(value)) {
@@ -528,6 +541,9 @@ function createRuntimeBinding(state) {
   });
 }
 function normalizeEventName(name) {
+  if (typeof name !== "string") {
+    throw new Error("[Holo Events] Event names must be non-empty strings.");
+  }
   const normalized = name.trim();
   if (!normalized) {
     throw new Error("[Holo Events] Event names must be non-empty strings.");
@@ -541,7 +557,7 @@ function resolveDispatchedEventName(event) {
   if (!isEventDefinition(event)) {
     throw new Error("[Holo Events] Events must be plain objects.");
   }
-  const explicitName = event.name?.trim();
+  const explicitName = eventInternals.normalizeOptionalString(event.name, "Event name");
   if (!explicitName) {
     throw new Error("[Holo Events] Dispatching an event definition requires an explicit event name.");
   }
@@ -786,7 +802,7 @@ var eventRuntimeInternals = {
   executeListener,
   executeSyncListeners,
   getRuntimeState,
-  isPlainObject,
+  isPlainObject: isPlainObject2,
   normalizeEventName,
   requireRegisteredEvent,
   resolveDispatchedEventName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/events",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Holo-JS Framework - event contracts and runtime surface",
   "type": "module",
   "license": "MIT",
@@ -23,10 +23,10 @@
     "test": "vitest --run"
   },
   "dependencies": {
-    "@holo-js/db": "^0.1.4"
+    "@holo-js/db": "^0.1.6"
   },
   "peerDependencies": {
-    "@holo-js/queue": "^0.1.4"
+    "@holo-js/queue": "^0.1.6"
   },
   "peerDependenciesMeta": {
     "@holo-js/queue": {
@@ -34,9 +34,10 @@
     }
   },
   "devDependencies": {
+    "@holo-js/queue": "^0.1.6",
     "@types/node": "^22.10.2",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
+    "vitest": "^4.1.5"
   }
 }