@semiont/api-client 0.2.2-build.15 → 0.2.2-build.16

package/dist/utils/index.js

@@ -1,28 +1,599 @@
-"use strict";
-/**
- * SDK utilities for @semiont/api-client
- *
- * Pure TypeScript helpers for working with Semiont data structures.
- * No React dependencies - safe to use in any JavaScript environment.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+// src/branded-types.ts
+function resourceUri(uri) {
+  if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
+    throw new TypeError(`Expected ResourceUri, got: ${uri}`);
+  }
+  return uri;
+}
+
+// src/utils/annotations.ts
+function getBodySource(body) {
+  if (Array.isArray(body)) {
+    for (const item of body) {
+      if (typeof item === "object" && item !== null && "type" in item && "source" in item) {
+        const itemType = item.type;
+        const itemSource = item.source;
+        if (itemType === "SpecificResource" && typeof itemSource === "string") {
+          return resourceUri(itemSource);
+        }
+      }
+    }
+    return null;
+  }
+  if (typeof body === "object" && body !== null && "type" in body && "source" in body) {
+    const bodyType = body.type;
+    const bodySource = body.source;
+    if (bodyType === "SpecificResource" && typeof bodySource === "string") {
+      return resourceUri(bodySource);
+    }
+  }
+  return null;
+}
+function getBodyType(body) {
+  if (Array.isArray(body)) {
+    if (body.length === 0) {
+      return null;
+    }
+    if (typeof body[0] === "object" && body[0] !== null && "type" in body[0]) {
+      const firstType = body[0].type;
+      if (firstType === "TextualBody" || firstType === "SpecificResource") {
+        return firstType;
+      }
+    }
+    return null;
+  }
+  if (typeof body === "object" && body !== null && "type" in body) {
+    const bodyType = body.type;
+    if (bodyType === "TextualBody" || bodyType === "SpecificResource") {
+      return bodyType;
+    }
+  }
+  return null;
+}
+function isBodyResolved(body) {
+  return getBodySource(body) !== null;
+}
+function getTargetSource(target) {
+  if (typeof target === "string") {
+    return resourceUri(target);
+  }
+  return resourceUri(target.source);
+}
+function getTargetSelector(target) {
+  if (typeof target === "string") {
+    return void 0;
+  }
+  return target.selector;
+}
+function hasTargetSelector(target) {
+  return typeof target !== "string" && target.selector !== void 0;
+}
+function getEntityTypes(annotation) {
+  if (Array.isArray(annotation.body)) {
+    const entityTags = [];
+    for (const item of annotation.body) {
+      if (typeof item === "object" && item !== null && "type" in item && "value" in item && "purpose" in item) {
+        const itemType = item.type;
+        const itemValue = item.value;
+        const itemPurpose = item.purpose;
+        if (itemType === "TextualBody" && itemPurpose === "tagging" && typeof itemValue === "string" && itemValue.length > 0) {
+          entityTags.push(itemValue);
+        }
+      }
+    }
+    return entityTags;
+  }
+  return [];
+}
+function isHighlight(annotation) {
+  return annotation.motivation === "highlighting";
+}
+function isReference(annotation) {
+  return annotation.motivation === "linking";
+}
+function isAssessment(annotation) {
+  return annotation.motivation === "assessing";
+}
+function isComment(annotation) {
+  return annotation.motivation === "commenting";
+}
+function isTag(annotation) {
+  return annotation.motivation === "tagging";
+}
+function getCommentText(annotation) {
+  if (!isComment(annotation)) return void 0;
+  const body = Array.isArray(annotation.body) ? annotation.body[0] : annotation.body;
+  if (body && "value" in body) {
+    return body.value;
+  }
+  return void 0;
+}
+function getTagCategory(annotation) {
+  if (!isTag(annotation)) return void 0;
+  const bodies = Array.isArray(annotation.body) ? annotation.body : [annotation.body];
+  const taggingBody = bodies.find((b) => b && "purpose" in b && b.purpose === "tagging");
+  if (taggingBody && "value" in taggingBody) {
+    return taggingBody.value;
+  }
+  return void 0;
+}
+function getTagSchemaId(annotation) {
+  if (!isTag(annotation)) return void 0;
+  const bodies = Array.isArray(annotation.body) ? annotation.body : [annotation.body];
+  const classifyingBody = bodies.find((b) => b && "purpose" in b && b.purpose === "classifying");
+  if (classifyingBody && "value" in classifyingBody) {
+    return classifyingBody.value;
+  }
+  return void 0;
+}
+function isStubReference(annotation) {
+  return isReference(annotation) && !isBodyResolved(annotation.body);
+}
+function isResolvedReference(annotation) {
+  return isReference(annotation) && isBodyResolved(annotation.body);
+}
+function getExactText(selector) {
+  if (!selector) {
+    return "";
+  }
+  const selectors = Array.isArray(selector) ? selector : [selector];
+  const quoteSelector = selectors.find((s) => s.type === "TextQuoteSelector");
+  if (quoteSelector) {
+    return quoteSelector.exact;
+  }
+  return "";
+}
+function getAnnotationExactText(annotation) {
+  const selector = getTargetSelector(annotation.target);
+  return getExactText(selector);
+}
+function getPrimarySelector(selector) {
+  if (Array.isArray(selector)) {
+    if (selector.length === 0) {
+      throw new Error("Empty selector array");
+    }
+    const first = selector[0];
+    if (!first) {
+      throw new Error("Invalid selector array");
+    }
+    return first;
+  }
+  return selector;
+}
+function getTextPositionSelector(selector) {
+  if (!selector) return null;
+  const selectors = Array.isArray(selector) ? selector : [selector];
+  const found = selectors.find((s) => s.type === "TextPositionSelector");
+  if (!found) return null;
+  return found.type === "TextPositionSelector" ? found : null;
+}
+function getTextQuoteSelector(selector) {
+  const selectors = Array.isArray(selector) ? selector : [selector];
+  const found = selectors.find((s) => s.type === "TextQuoteSelector");
+  if (!found) return null;
+  return found.type === "TextQuoteSelector" ? found : null;
+}
+function getSvgSelector(selector) {
+  if (!selector) return null;
+  const selectors = Array.isArray(selector) ? selector : [selector];
+  const found = selectors.find((s) => s.type === "SvgSelector");
+  if (!found) return null;
+  return found.type === "SvgSelector" ? found : null;
+}
+function validateSvgMarkup(svg) {
+  if (!svg.includes('xmlns="http://www.w3.org/2000/svg"')) {
+    return 'SVG must include xmlns="http://www.w3.org/2000/svg" attribute';
+  }
+  if (!svg.includes("<svg") || !svg.includes("</svg>")) {
+    return "SVG must have opening and closing tags";
+  }
+  const shapeElements = ["rect", "circle", "ellipse", "polygon", "polyline", "path", "line"];
+  const hasShape = shapeElements.some(
+    (shape) => svg.includes(`<${shape}`) || svg.includes(`<${shape} `)
+  );
+  if (!hasShape) {
+    return "SVG must contain at least one shape element (rect, circle, ellipse, polygon, polyline, path, or line)";
+  }
+  return null;
+}
+function extractBoundingBox(svg) {
+  const viewBoxMatch = svg.match(/<svg[^>]*viewBox="([^"]+)"/);
+  if (viewBoxMatch) {
+    const values = viewBoxMatch[1].split(/\s+/).map(parseFloat);
+    if (values.length === 4 && values.every((v) => !isNaN(v))) {
+      return {
+        x: values[0],
+        y: values[1],
+        width: values[2],
+        height: values[3]
+      };
+    }
+  }
+  const svgTagMatch = svg.match(/<svg[^>]*>/);
+  if (svgTagMatch) {
+    const svgTag = svgTagMatch[0];
+    const widthMatch = svgTag.match(/width="([^"]+)"/);
+    const heightMatch = svgTag.match(/height="([^"]+)"/);
+    if (widthMatch && heightMatch) {
+      const width = parseFloat(widthMatch[1]);
+      const height = parseFloat(heightMatch[1]);
+      if (!isNaN(width) && !isNaN(height)) {
+        return { x: 0, y: 0, width, height };
+      }
+    }
+  }
+  return null;
+}
+
+// src/utils/events.ts
+function getAnnotationUriFromEvent(event) {
+  const eventData = event.event;
+  const payload = eventData.payload;
+  if (!payload) {
+    return null;
+  }
+  switch (eventData.type) {
+    case "annotation.added":
+      return payload.annotation?.id || null;
+    case "annotation.removed":
+    case "annotation.body.updated":
+      if (payload.annotationId && eventData.resourceId) {
+        try {
+          const resourceUri2 = eventData.resourceId;
+          const baseUrl = resourceUri2.substring(0, resourceUri2.lastIndexOf("/resources/"));
+          return `${baseUrl}/annotations/${payload.annotationId}`;
+        } catch (e) {
+          return null;
+        }
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+function isEventRelatedToAnnotation(event, annotationUri) {
+  const eventAnnotationUri = getAnnotationUriFromEvent(event);
+  return eventAnnotationUri === annotationUri;
+}
+function isResourceEvent(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";
+}
+function formatEventType(type, t, payload) {
+  switch (type) {
+    case "resource.created":
+      return t("resourceCreated");
+    case "resource.cloned":
+      return t("resourceCloned");
+    case "resource.archived":
+      return t("resourceArchived");
+    case "resource.unarchived":
+      return t("resourceUnarchived");
+    case "annotation.added": {
+      const motivation = payload?.annotation?.motivation;
+      if (motivation === "highlighting") return t("highlightAdded");
+      if (motivation === "linking") return t("referenceCreated");
+      if (motivation === "assessing") return t("assessmentAdded");
+      return t("annotationAdded");
+    }
+    case "annotation.removed": {
+      return t("annotationRemoved");
+    }
+    case "annotation.body.updated": {
+      return t("annotationBodyUpdated");
+    }
+    case "entitytag.added":
+      return t("entitytagAdded");
+    case "entitytag.removed":
+      return t("entitytagRemoved");
+    case "entitytype.added":
+      return t("entitytypeAdded");
+    case "job.completed":
+    case "job.started":
+    case "job.progress":
+    case "job.failed":
+      return t("jobEvent");
+    default:
+      const _exhaustiveCheck = type;
+      return _exhaustiveCheck;
+  }
+}
+function getEventEmoji(type, payload) {
+  switch (type) {
+    case "resource.created":
+    case "resource.cloned":
+    case "resource.archived":
+    case "resource.unarchived":
+      return "\u{1F4C4}";
+    case "annotation.added": {
+      const motivation = payload?.annotation?.motivation;
+      if (motivation === "highlighting") return "\u{1F7E1}";
+      if (motivation === "linking") return "\u{1F535}";
+      if (motivation === "assessing") return "\u{1F534}";
+      return "\u{1F4DD}";
+    }
+    case "annotation.removed": {
+      return "\u{1F5D1}\uFE0F";
+    }
+    case "annotation.body.updated": {
+      return "\u270F\uFE0F";
+    }
+    case "entitytag.added":
+    case "entitytag.removed":
+      return "\u{1F3F7}\uFE0F";
+    case "entitytype.added":
+      return "\u{1F3F7}\uFE0F";
+    // Same emoji as entitytag (global entity type collection)
+    case "job.completed":
+      return "\u{1F517}";
+    // Link emoji for linked document creation
+    case "job.started":
+    case "job.progress":
+      return "\u2699\uFE0F";
+    // Gear for job processing
+    case "job.failed":
+      return "\u274C";
+    // X mark for failed jobs
+    default:
+      const _exhaustiveCheck = type;
+      return _exhaustiveCheck;
+  }
+}
+function formatRelativeTime(timestamp, t) {
+  const date = new Date(timestamp);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 6e4);
+  const diffHours = Math.floor(diffMs / 36e5);
+  const diffDays = Math.floor(diffMs / 864e5);
+  if (diffMins < 1) return t("justNow");
+  if (diffMins < 60) return t("minutesAgo", { count: diffMins });
+  if (diffHours < 24) return t("hoursAgo", { count: diffHours });
+  if (diffDays < 7) return t("daysAgo", { count: diffDays });
+  return date.toLocaleDateString();
+}
+function truncateText(text, maxLength = 50) {
+  const trimmed = text.trim();
+  return trimmed.length > maxLength ? trimmed.substring(0, maxLength) + "..." : trimmed;
+}
+function getEventDisplayContent(event, annotations, allEvents) {
+  const eventData = event.event;
+  const payload = eventData.payload;
+  switch (eventData.type) {
+    case "resource.created":
+    case "resource.cloned": {
+      return { exact: payload.name, isQuoted: false, isTag: false };
+    }
+    // Unified annotation events
+    case "annotation.body.updated": {
+      const annotation = annotations.find(
+        (a) => a.id.endsWith(`/annotations/${payload.annotationId}`)
+      );
+      if (annotation?.target) {
+        try {
+          const targetSelector = getTargetSelector(annotation.target);
+          const exact = getExactText(targetSelector);
+          if (exact) {
+            return { exact: truncateText(exact), isQuoted: true, isTag: false };
+          }
+        } catch {
+        }
+      }
+      return null;
+    }
+    case "annotation.removed": {
+      const addedEvent = allEvents.find(
+        (e) => e.event.type === "annotation.added" && e.event.payload.annotation?.id?.endsWith(`/annotations/${payload.annotationId}`)
+      );
+      if (addedEvent) {
+        const addedPayload = addedEvent.event.payload;
+        try {
+          const exact = getExactText(addedPayload.annotation.target.selector);
+          if (exact) {
+            return { exact: truncateText(exact), isQuoted: true, isTag: false };
+          }
+        } catch {
+        }
+      }
+      return null;
+    }
+    case "annotation.added": {
+      try {
+        const exact = getExactText(payload.annotation.target.selector);
+        if (exact) {
+          return { exact: truncateText(exact), isQuoted: true, isTag: false };
+        }
+      } catch {
+      }
+      return null;
+    }
+    case "entitytag.added":
+    case "entitytag.removed": {
+      return { exact: payload.entityType, isQuoted: false, isTag: true };
+    }
+    case "job.completed": {
+      if (payload.annotationUri) {
+        const annotation = annotations.find(
+          (a) => a.id === payload.annotationUri
+        );
+        if (annotation?.target) {
+          try {
+            const targetSelector = getTargetSelector(annotation.target);
+            const exact = getExactText(targetSelector);
+            if (exact) {
+              return { exact: truncateText(exact), isQuoted: true, isTag: false };
+            }
+          } catch {
+          }
+        }
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function getEventEntityTypes(event) {
+  const eventData = event.event;
+  if (eventData.type === "annotation.added") {
+    const payload = eventData.payload;
+    const motivation = payload?.annotation?.motivation;
+    if (motivation === "linking") {
+      return payload.annotation?.body?.entityTypes ?? [];
+    }
+  }
+  return [];
+}
+function getResourceCreationDetails(event) {
+  const eventData = event.event;
+  const payload = eventData.payload;
+  if (eventData.type === "resource.created") {
+    return {
+      type: "created",
+      method: payload.creationMethod || "unknown",
+      userId: eventData.userId,
+      metadata: payload.metadata
+    };
+  }
+  if (eventData.type === "resource.cloned") {
+    return {
+      type: "cloned",
+      method: payload.creationMethod || "clone",
+      userId: eventData.userId,
+      sourceDocId: payload.parentResourceId,
+      parentResourceId: payload.parentResourceId,
+      metadata: payload.metadata
+    };
+  }
+  return null;
+}
+
+// src/utils/locales.ts
+var LOCALES = [
+  { code: "ar", nativeName: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629", englishName: "Arabic" },
+  { code: "bn", nativeName: "\u09AC\u09BE\u0982\u09B2\u09BE", englishName: "Bengali" },
+  { code: "cs", nativeName: "\u010Ce\u0161tina", englishName: "Czech" },
+  { code: "da", nativeName: "Dansk", englishName: "Danish" },
+  { code: "de", nativeName: "Deutsch", englishName: "German" },
+  { code: "el", nativeName: "\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC", englishName: "Greek" },
+  { code: "en", nativeName: "English", englishName: "English" },
+  { code: "es", nativeName: "Espa\xF1ol", englishName: "Spanish" },
+  { code: "fa", nativeName: "\u0641\u0627\u0631\u0633\u06CC", englishName: "Persian" },
+  { code: "fi", nativeName: "Suomi", englishName: "Finnish" },
+  { code: "fr", nativeName: "Fran\xE7ais", englishName: "French" },
+  { code: "he", nativeName: "\u05E2\u05D1\u05E8\u05D9\u05EA", englishName: "Hebrew" },
+  { code: "hi", nativeName: "\u0939\u093F\u0928\u094D\u0926\u0940", englishName: "Hindi" },
+  { code: "id", nativeName: "Bahasa Indonesia", englishName: "Indonesian" },
+  { code: "it", nativeName: "Italiano", englishName: "Italian" },
+  { code: "ja", nativeName: "\u65E5\u672C\u8A9E", englishName: "Japanese" },
+  { code: "ko", nativeName: "\uD55C\uAD6D\uC5B4", englishName: "Korean" },
+  { code: "ms", nativeName: "Bahasa Melayu", englishName: "Malay" },
+  { code: "nl", nativeName: "Nederlands", englishName: "Dutch" },
+  { code: "no", nativeName: "Norsk", englishName: "Norwegian" },
+  { code: "pl", nativeName: "Polski", englishName: "Polish" },
+  { code: "pt", nativeName: "Portugu\xEAs", englishName: "Portuguese" },
+  { code: "ro", nativeName: "Rom\xE2n\u0103", englishName: "Romanian" },
+  { code: "sv", nativeName: "Svenska", englishName: "Swedish" },
+  { code: "th", nativeName: "\u0E44\u0E17\u0E22", englishName: "Thai" },
+  { code: "tr", nativeName: "T\xFCrk\xE7e", englishName: "Turkish" },
+  { code: "uk", nativeName: "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430", englishName: "Ukrainian" },
+  { code: "vi", nativeName: "Ti\u1EBFng Vi\u1EC7t", englishName: "Vietnamese" },
+  { code: "zh", nativeName: "\u4E2D\u6587", englishName: "Chinese" }
+];
+var localeByCode = new Map(
+  LOCALES.map((locale) => [locale.code.toLowerCase(), locale])
+);
+function getLocaleInfo(code) {
+  if (!code) return void 0;
+  return localeByCode.get(code.toLowerCase());
+}
+function getLocaleNativeName(code) {
+  return getLocaleInfo(code)?.nativeName;
+}
+function getLocaleEnglishName(code) {
+  return getLocaleInfo(code)?.englishName;
+}
+function formatLocaleDisplay(code) {
+  if (!code) return void 0;
+  const info = getLocaleInfo(code);
+  if (!info) return code;
+  return `${info.nativeName} (${code.toLowerCase()})`;
+}
+function getAllLocaleCodes() {
+  return LOCALES.map((l) => l.code);
+}
+
+// src/utils/resources.ts
+function getResourceId(resource) {
+  if (!resource) return void 0;
+  const fullId = resource["@id"];
+  if (fullId.includes("/resources/")) {
+    const parts = fullId.split("/resources/");
+    const lastPart = parts[parts.length - 1];
+    return lastPart || void 0;
+  }
+  return void 0;
+}
+function getPrimaryRepresentation(resource) {
+  if (!resource?.representations) return void 0;
+  const reps = Array.isArray(resource.representations) ? resource.representations : [resource.representations];
+  return reps[0];
+}
+function getPrimaryMediaType(resource) {
+  return getPrimaryRepresentation(resource)?.mediaType;
+}
+function getChecksum(resource) {
+  return getPrimaryRepresentation(resource)?.checksum;
+}
+function getLanguage(resource) {
+  return getPrimaryRepresentation(resource)?.language;
+}
+
+// src/utils/validation.ts
+var JWTTokenSchema = {
+  parse(token) {
+    if (typeof token !== "string") {
+      throw new Error("Token must be a string");
+    }
+    if (!token || token.length === 0) {
+      throw new Error("Token is required");
+    }
+    const jwtRegex = /^[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]*$/;
+    if (!jwtRegex.test(token)) {
+      throw new Error("Invalid JWT token format");
+    }
+    return token;
+  },
+  safeParse(token) {
+    try {
+      const validated = this.parse(token);
+      return { success: true, data: validated };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Invalid JWT token"
+      };
+    }
+  }
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./annotations"), exports);
-__exportStar(require("./events"), exports);
-__exportStar(require("./locales"), exports);
-__exportStar(require("./resources"), exports);
-__exportStar(require("./validation"), exports);
+function validateData(schema, data) {
+  try {
+    const validated = schema.parse(data);
+    return { success: true, data: validated };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Validation failed"
+    };
+  }
+}
+function isValidEmail(email) {
+  if (email.length < 1 || email.length > 255) {
+    return false;
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+
+export { JWTTokenSchema, LOCALES, extractBoundingBox, formatEventType, formatLocaleDisplay, formatRelativeTime, getAllLocaleCodes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getEntityTypes, getEventDisplayContent, getEventEmoji, getEventEntityTypes, getExactText, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceCreationDetails, getResourceId, getSvgSelector, getTagCategory, getTagSchemaId, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, hasTargetSelector, isAssessment, isBodyResolved, isComment, isEventRelatedToAnnotation, isHighlight, isReference, isResolvedReference, isResourceEvent, isStubReference, isTag, isValidEmail, validateData, validateSvgMarkup };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map