@semiont/core 0.2.34-build.88 → 0.2.34-build.90

package/dist/index.js

@@ -1,7 +1,66 @@
-import { resourceUri, annotationUri } from '@semiont/api-client';
+import { Subject } from 'rxjs';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
 
+// src/branded-types.ts
+function email(value) {
+  return value;
+}
+function authCode(value) {
+  return value;
+}
+function googleCredential(value) {
+  return value;
+}
+function accessToken(value) {
+  return value;
+}
+function refreshToken(value) {
+  return value;
+}
+function mcpToken(value) {
+  return value;
+}
+function cloneToken(value) {
+  return value;
+}
+function jobId(value) {
+  return value;
+}
+function userDID(value) {
+  return value;
+}
+function entityType(value) {
+  return value;
+}
+function searchQuery(value) {
+  return value;
+}
+function baseUrl(value) {
+  return value;
+}
+function resourceUri(uri) {
+  if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
+    throw new TypeError(`Expected ResourceUri, got: ${uri}`);
+  }
+  return uri;
+}
+function annotationUri(uri) {
+  if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
+    throw new TypeError(`Expected AnnotationUri, got: ${uri}`);
+  }
+  return uri;
+}
+function resourceAnnotationUri(uri) {
+  if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
+    throw new TypeError(`Expected ResourceAnnotationUri, got: ${uri}`);
+  }
+  if (!uri.includes("/resources/") || !uri.includes("/annotations/")) {
+    throw new TypeError(`Expected nested ResourceAnnotationUri format, got: ${uri}`);
+  }
+  return uri;
+}
+
 // src/creation-methods.ts
 var CREATION_METHODS = {
   API: "api",
@@ -34,6 +93,8 @@ function annotationId(id) {
 function userId(id) {
   return id;
 }
+
+// src/uri-utils.ts
 function resourceIdToURI(id, publicURL) {
   const normalizedBase = publicURL.endsWith("/") ? publicURL.slice(0, -1) : publicURL;
   return resourceUri(`${normalizedBase}/resources/${id}`);
@@ -98,8 +159,8 @@ function getAnnotationUriFromEvent(event) {
     if (eventData.payload.annotationId && eventData.resourceId) {
       try {
         const resourceUri2 = eventData.resourceId;
-        const baseUrl = resourceUri2.substring(0, resourceUri2.lastIndexOf("/resources/"));
-        return `${baseUrl}/annotations/${eventData.payload.annotationId}`;
+        const baseUrl2 = resourceUri2.substring(0, resourceUri2.lastIndexOf("/resources/"));
+        return `${baseUrl2}/annotations/${eventData.payload.annotationId}`;
       } catch (e) {
         return null;
       }
@@ -114,6 +175,124 @@ function isEventRelatedToAnnotation(event, annotationUri2) {
 function isResourceEvent2(event) {
   return event && typeof event.event === "object" && typeof event.event.id === "string" && typeof event.event.timestamp === "string" && typeof event.event.resourceId === "string" && typeof event.event.type === "string" && typeof event.metadata === "object" && typeof event.metadata.sequenceNumber === "number";
 }
+var EventBus = class {
+  subjects;
+  isDestroyed;
+  constructor() {
+    this.subjects = /* @__PURE__ */ new Map();
+    this.isDestroyed = false;
+  }
+  /**
+   * Get the RxJS Subject for an event
+   *
+   * Returns a typed Subject that can be used with all RxJS operators.
+   * Subjects are created lazily on first access.
+   *
+   * @param eventName - The event name
+   * @returns The RxJS Subject for this event
+   *
+   * @example
+   * ```typescript
+   * // Emit
+   * eventBus.get('annotation:hover').next({ annotationId: 'ann-1' });
+   *
+   * // Subscribe
+   * const sub = eventBus.get('annotation:hover').subscribe(handleHover);
+   *
+   * // With operators
+   * eventBus.get('annotation:hover')
+   *   .pipe(debounceTime(100), distinctUntilChanged())
+   *   .subscribe(handleHover);
+   * ```
+   */
+  get(eventName) {
+    if (this.isDestroyed) {
+      throw new Error(`Cannot access event '${String(eventName)}' on destroyed bus`);
+    }
+    if (!this.subjects.has(eventName)) {
+      this.subjects.set(eventName, new Subject());
+    }
+    return this.subjects.get(eventName);
+  }
+  /**
+   * Destroy the event bus and complete all subjects
+   *
+   * After calling destroy(), no new events can be emitted or subscribed to.
+   * All active subscriptions will be completed.
+   */
+  destroy() {
+    if (this.isDestroyed) {
+      return;
+    }
+    for (const subject of this.subjects.values()) {
+      subject.complete();
+    }
+    this.subjects.clear();
+    this.isDestroyed = true;
+  }
+  /**
+   * Check if the event bus has been destroyed
+   */
+  get destroyed() {
+    return this.isDestroyed;
+  }
+  /**
+   * Create a resource-scoped event bus
+   *
+   * Events emitted or subscribed through the scoped bus are isolated to that resource.
+   * Internally, events are namespaced but the API remains identical to the parent bus.
+   *
+   * @param resourceId - Resource identifier to scope events to
+   * @returns A scoped event bus for this resource
+   *
+   * @example
+   * ```typescript
+   * const eventBus = new EventBus();
+   * const resource1 = eventBus.scope('resource-1');
+   * const resource2 = eventBus.scope('resource-2');
+   *
+   * // These are isolated - only resource1 subscribers will fire
+   * resource1.get('detection:progress').next({ status: 'started' });
+   * ```
+   */
+  scope(resourceId2) {
+    return new ScopedEventBus(this, resourceId2);
+  }
+};
+var ScopedEventBus = class _ScopedEventBus {
+  constructor(parent, scopePrefix) {
+    this.parent = parent;
+    this.scopePrefix = scopePrefix;
+  }
+  /**
+   * Get the RxJS Subject for a scoped event
+   *
+   * Returns the same type as the parent bus, but events are isolated to this scope.
+   * Internally uses namespaced keys but preserves type safety.
+   *
+   * @param event - The event name
+   * @returns The RxJS Subject for this scoped event
+   */
+  get(event) {
+    const scopedKey = `${this.scopePrefix}:${event}`;
+    const parentSubjects = this.parent.subjects;
+    if (!parentSubjects.has(scopedKey)) {
+      parentSubjects.set(scopedKey, new Subject());
+    }
+    return parentSubjects.get(scopedKey);
+  }
+  /**
+   * Create a nested scope
+   *
+   * Allows hierarchical scoping like `resource-1:subsystem-a`
+   *
+   * @param subScope - Additional scope level
+   * @returns A nested scoped event bus
+   */
+  scope(subScope) {
+    return new _ScopedEventBus(this.parent, `${this.scopePrefix}:${subScope}`);
+  }
+};
 
 // src/annotation-utils.ts
 function findBodyItem(body, targetItem) {
@@ -2074,6 +2253,13 @@ function displayConfiguration(config) {
   console.log("Environment Configuration:");
   console.log(JSON.stringify(config, null, 2));
 }
+function createConfigLoader(reader) {
+  return (projectRoot, environment) => {
+    const baseContent = reader.readIfExists(`${projectRoot}/semiont.json`);
+    const envContent = reader.readRequired(`${projectRoot}/environments/${environment}.json`);
+    return parseAndMergeConfigs(baseContent, envContent, process.env, environment, projectRoot);
+  };
+}
 
 // src/config/environment-validator.ts
 function isValidEnvironment(value, availableEnvironments) {
@@ -2111,6 +2297,6 @@ function getAllPlatformTypes() {
 var CORE_TYPES_VERSION = "0.1.0";
 var SDK_VERSION = "0.1.0";
 
-export { APIError, CORE_TYPES_VERSION, CREATION_METHODS, ConfigurationError, ConflictError, NotFoundError, SDK_VERSION, ScriptError, SemiontError, UnauthorizedError, ValidationError, annotationId, annotationIdToURI, deepMerge, didToAgent, displayConfiguration, extractResourceUriFromAnnotationUri, findBodyItem, formatErrors, getAllPlatformTypes, getAnnotationUriFromEvent, getEventType, getNodeEnvForEnvironment, hasAWSConfig, isAnnotationId, isArray, isBoolean, isDefined, isEventRelatedToAnnotation, isFunction, isNull, isNullish, isNumber, isObject, isResourceEvent, isResourceId, isResourceScopedEvent, isResourceEvent2 as isStoredEvent, isString, isSystemEvent, isUndefined, isValidPlatformType, listEnvironmentNames, parseAndMergeConfigs, parseEnvironment, resolveEnvVars, resourceId, resourceIdToURI, uriToAnnotationId, uriToAnnotationIdOrPassthrough, uriToResourceId, userId, userToAgent, userToDid, validateEnvironment, validateEnvironmentConfig, validateSemiontConfig, validateSiteConfig };
+export { APIError, CORE_TYPES_VERSION, CREATION_METHODS, ConfigurationError, ConflictError, EventBus, NotFoundError, SDK_VERSION, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, annotationId, annotationIdToURI, annotationUri, authCode, baseUrl, cloneToken, createConfigLoader, deepMerge, didToAgent, displayConfiguration, email, entityType, extractResourceUriFromAnnotationUri, findBodyItem, formatErrors, getAllPlatformTypes, getAnnotationUriFromEvent, getEventType, getNodeEnvForEnvironment, googleCredential, hasAWSConfig, isAnnotationId, isArray, isBoolean, isDefined, isEventRelatedToAnnotation, isFunction, isNull, isNullish, isNumber, isObject, isResourceEvent, isResourceId, isResourceScopedEvent, isResourceEvent2 as isStoredEvent, isString, isSystemEvent, isUndefined, isValidPlatformType, jobId, listEnvironmentNames, mcpToken, parseAndMergeConfigs, parseEnvironment, refreshToken, resolveEnvVars, resourceAnnotationUri, resourceId, resourceIdToURI, resourceUri, searchQuery, uriToAnnotationId, uriToAnnotationIdOrPassthrough, uriToResourceId, userDID, userId, userToAgent, userToDid, validateEnvironment, validateEnvironmentConfig, validateSemiontConfig, validateSiteConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map