@singi-labs/sifa-sdk 0.12.8 → 0.12.9

package/dist/index.cjs

@@ -2409,34 +2409,34 @@ function resolveCardHealth(item) {
     if (subject != null && typeof subject === "object") {
       const subjectUri = stringOrNull(subject.uri);
       if (subjectUri) {
-        const parsed2 = parseAtUri(subjectUri);
-        if (parsed2) {
-          return urlHealth(`https://smokesignal.events/${parsed2.did}/${parsed2.rkey}`);
+        const parsed3 = parseAtUri(subjectUri);
+        if (parsed3) {
+          return urlHealth(`https://smokesignal.events/${parsed3.did}/${parsed3.rkey}`);
         }
       }
     }
     return { url: null, strategy: "none" };
   }
   if (collection === "community.lexicon.calendar.event") {
-    const parsed2 = parseAtUri(uri);
-    if (parsed2) {
-      return recordHealth(`https://smokesignal.events/${parsed2.did}/${parsed2.rkey}`);
+    const parsed3 = parseAtUri(uri);
+    if (parsed3) {
+      return recordHealth(`https://smokesignal.events/${parsed3.did}/${parsed3.rkey}`);
     }
     return { url: null, strategy: "none" };
   }
   if (collection === "quest.atmo.event") {
-    const parsed2 = parseAtUri(uri);
-    if (parsed2) {
-      return recordHealth(`https://atmo.rsvp/p/${parsed2.did}/e/${parsed2.rkey}`);
+    const parsed3 = parseAtUri(uri);
+    if (parsed3) {
+      return recordHealth(`https://atmo.rsvp/p/${parsed3.did}/e/${parsed3.rkey}`);
     }
     return { url: null, strategy: "none" };
   }
   if (collection === "quest.atmo.checkin") {
     const eventUri = stringOrNull(record.event);
     if (eventUri) {
-      const parsed2 = parseAtUri(eventUri);
-      if (parsed2) {
-        return urlHealth(`https://atmo.rsvp/p/${parsed2.did}/e/${parsed2.rkey}`);
+      const parsed3 = parseAtUri(eventUri);
+      if (parsed3) {
+        return urlHealth(`https://atmo.rsvp/p/${parsed3.did}/e/${parsed3.rkey}`);
       }
     }
     return { url: null, strategy: "none" };
@@ -2581,9 +2581,9 @@ function getPublisherFromSiteUrl(siteUrl) {
   let hostname;
   let homeUrl;
   try {
-    const parsed2 = new URL(siteUrl);
-    hostname = parsed2.hostname;
-    homeUrl = `${parsed2.protocol}//${parsed2.hostname}`;
+    const parsed3 = new URL(siteUrl);
+    hostname = parsed3.hostname;
+    homeUrl = `${parsed3.protocol}//${parsed3.hostname}`;
   } catch {
     return {
       id: STANDARD_PUBLISHER_ID,
@@ -2602,6 +2602,312 @@ function getPublisherFromSiteUrl(siteUrl) {
   };
 }
 
+// src/stream/verbs.json
+var verbs_default = {
+  $schema: "https://sifa.id/schemas/activity-verbs/v1.json",
+  version: "1.0.0",
+  updated: "2026-07-17",
+  defaultVerb: "created",
+  verbs: {
+    "app.bsky.feed.post": "posted",
+    "blue.flashes.feed.post": "posted",
+    "social.psky.feed.post": "posted",
+    "social.popfeed.feed.post": "posted",
+    "social.popfeed.feed.note": "posted",
+    "fyi.unravel.frontpage.post": "posted",
+    "forum.barazo.post": "posted",
+    "app.bsky.feed.repost": "reposted",
+    "com.whtwnd.blog.entry": "published",
+    "site.standard.document": "published",
+    "computer.aetheros.page": "published",
+    "link.pastesphere.snippet": "published",
+    "pub.leaflet.comment": "published",
+    "id.sifa.profile.presentation": "presented",
+    "id.sifa.profile.presentationDelivery": "presented",
+    "id.sifa.endorsement": "endorsed",
+    "sh.tangled.repo": "shipped",
+    "sh.tangled.repo.issue": "shipped",
+    "sh.tangled.repo.pull": "shipped",
+    "app.sidetrail.trail": "shipped",
+    "app.sidetrail.walk": "shipped",
+    "social.colibri.membership": "joined",
+    "id.sifa.project.membership": "joined",
+    "id.sifa.project.member": "joined",
+    "community.lexicon.calendar.rsvp": "joined",
+    "at.youandme.connection": "joined",
+    "id.sifa.graph.connection": "joined"
+  }
+};
+
+// src/stream/verbs.ts
+var STREAM_VERBS = [
+  "posted",
+  "reposted",
+  "published",
+  "presented",
+  "endorsed",
+  "joined",
+  "shipped",
+  "created"
+];
+var streamVerbSchema = zod.z.enum(STREAM_VERBS);
+var verbMapSchema = zod.z.object({
+  version: zod.z.string(),
+  updated: zod.z.string(),
+  defaultVerb: streamVerbSchema,
+  verbs: zod.z.record(zod.z.string(), streamVerbSchema)
+});
+var parsed2 = verbMapSchema.parse(verbs_default);
+var ACTIVITY_VERBS = Object.freeze(parsed2);
+function verbForCollection(collection) {
+  if (!collection) return ACTIVITY_VERBS.defaultVerb;
+  return ACTIVITY_VERBS.verbs[collection] ?? ACTIVITY_VERBS.defaultVerb;
+}
+function getActivityVerbsVersion() {
+  return { version: ACTIVITY_VERBS.version, updated: ACTIVITY_VERBS.updated };
+}
+var rgbChannelSchema = zod.z.number().min(0).max(255);
+var rgbColorSchema = zod.z.object({
+  r: rgbChannelSchema,
+  g: rgbChannelSchema,
+  b: rgbChannelSchema
+});
+var aspectRatioSchema = zod.z.object({
+  width: zod.z.number(),
+  height: zod.z.number()
+});
+var streamSourceSchema = zod.z.object({
+  appId: zod.z.string(),
+  label: zod.z.string(),
+  color: zod.z.string()
+});
+var streamThemeSchema = zod.z.object({
+  background: rgbColorSchema,
+  foreground: rgbColorSchema,
+  accent: rgbColorSchema
+});
+var streamMediaResolvedSchema = zod.z.object({
+  url: zod.z.string(),
+  alt: zod.z.string(),
+  aspectRatio: aspectRatioSchema.optional(),
+  mimeType: zod.z.string().optional()
+});
+var streamMediaBlobSchema = zod.z.object({
+  did: zod.z.string(),
+  cid: zod.z.string(),
+  alt: zod.z.string(),
+  aspectRatio: aspectRatioSchema.optional(),
+  mimeType: zod.z.string().optional()
+});
+var streamMediaSchema = zod.z.union([
+  streamMediaResolvedSchema,
+  streamMediaBlobSchema
+]);
+var streamExternalLinkSchema = zod.z.object({
+  url: zod.z.string(),
+  title: zod.z.string().optional(),
+  thumb: zod.z.string().optional()
+});
+var streamCardBodySchema = zod.z.discriminatedUnion("kind", [
+  zod.z.object({ kind: zod.z.literal("text"), text: zod.z.string() }),
+  zod.z.object({ kind: zod.z.literal("media"), text: zod.z.string().optional() }),
+  zod.z.object({ kind: zod.z.literal("link"), text: zod.z.string().optional() }),
+  zod.z.object({
+    kind: zod.z.literal("track"),
+    text: zod.z.string().optional(),
+    trackTitle: zod.z.string().optional(),
+    artist: zod.z.string().optional()
+  }),
+  zod.z.object({ kind: zod.z.literal("generic"), text: zod.z.string().optional() })
+]);
+var streamCardSubjectSchema = zod.z.discriminatedUnion("kind", [
+  zod.z.object({
+    kind: zod.z.literal("post"),
+    post: zod.z.lazy(() => streamCardVMSchema)
+  }),
+  zod.z.object({
+    kind: zod.z.literal("person"),
+    did: zod.z.string(),
+    handle: zod.z.string().optional(),
+    displayName: zod.z.string().optional(),
+    avatar: zod.z.string().optional()
+  }),
+  zod.z.object({
+    kind: zod.z.literal("record"),
+    uri: zod.z.string(),
+    title: zod.z.string().optional()
+  })
+]);
+var streamCardVMSchema = zod.z.lazy(
+  () => zod.z.object({
+    uri: zod.z.string(),
+    cid: zod.z.string(),
+    verb: streamVerbSchema,
+    source: streamSourceSchema,
+    tier: zod.z.enum(["creation", "action", "filtered"]),
+    timestamp: zod.z.string(),
+    title: zod.z.string(),
+    body: streamCardBodySchema.optional(),
+    media: zod.z.array(streamMediaSchema).optional(),
+    externalLink: streamExternalLinkSchema.optional(),
+    theme: streamThemeSchema.optional(),
+    subject: zod.z.lazy(() => streamCardSubjectSchema).optional()
+  })
+);
+
+// src/stream/to-stream-card-vm.ts
+var DEFAULT_SOURCE_COLOR = "slate";
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : null;
+}
+function asNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function didFromUri(uri) {
+  const match = uri.match(/^at:\/\/(did:[^/]+)\//);
+  return match?.[1];
+}
+function blobCid(blob) {
+  const rec = asRecord(blob);
+  if (!rec) return void 0;
+  const ref = rec.ref;
+  if (typeof ref === "string") return ref;
+  const link2 = asRecord(ref)?.["$link"];
+  return typeof link2 === "string" ? link2 : void 0;
+}
+function aspectRatio(value) {
+  const rec = asRecord(value);
+  const width = rec?.width;
+  const height = rec?.height;
+  if (typeof width === "number" && typeof height === "number") return { width, height };
+  return void 0;
+}
+function buildSource(item, options) {
+  return {
+    appId: item.appId,
+    label: item.appName,
+    color: options.resolveSourceColor?.(item.appId) ?? DEFAULT_SOURCE_COLOR
+  };
+}
+var TITLE_BY_VERB = {
+  posted: (label) => `Posted on ${label}`,
+  reposted: () => "Reposted a post",
+  published: (label) => `Published on ${label}`,
+  presented: () => "Gave a presentation",
+  endorsed: () => "Wrote an endorsement",
+  joined: (label) => `Joined ${label}`,
+  shipped: (label) => `Shipped on ${label}`,
+  created: (label) => `Created a record on ${label}`
+};
+function buildTitle(verb, label) {
+  return TITLE_BY_VERB[verb](label);
+}
+function readTheme(record) {
+  const theme = asRecord(record?.publicationTheme ?? record?.theme);
+  if (!theme) return void 0;
+  const { background, foreground, accent } = theme;
+  if (isValidRgbColor(background) && isValidRgbColor(foreground) && isValidRgbColor(accent)) {
+    return { background, foreground, accent };
+  }
+  return void 0;
+}
+function bskyImages(embed, did) {
+  const images = embed.images;
+  if (!Array.isArray(images)) return [];
+  const out = [];
+  for (const raw of images) {
+    const img = asRecord(raw);
+    if (!img) continue;
+    const cid = blobCid(img.image);
+    if (!cid) continue;
+    const media = { did, cid, alt: asNonEmptyString(img.alt) ?? "" };
+    const ratio = aspectRatio(img.aspectRatio);
+    if (ratio) media.aspectRatio = ratio;
+    const mimeType = asNonEmptyString(asRecord(img.image)?.mimeType);
+    if (mimeType) media.mimeType = mimeType;
+    out.push(media);
+  }
+  return out;
+}
+function bskyExternal(embed) {
+  const external = asRecord(embed.external);
+  if (!external) return void 0;
+  const url = asNonEmptyString(external.uri);
+  if (!url) return void 0;
+  const link2 = { url };
+  const title = asNonEmptyString(external.title);
+  if (title) link2.title = title;
+  return link2;
+}
+function bskyEmbedContent(record, did) {
+  const embed = asRecord(record.embed);
+  if (!embed) return {};
+  const type = asNonEmptyString(embed["$type"]);
+  const target = type === "app.bsky.embed.recordWithMedia" ? asRecord(embed.media) : embed;
+  if (!target) return {};
+  if (Array.isArray(target.images)) {
+    const media = bskyImages(target, did);
+    return media.length > 0 ? { media } : {};
+  }
+  if (target.external != null) {
+    const externalLink = bskyExternal(target);
+    return externalLink ? { externalLink } : {};
+  }
+  return {};
+}
+function applyBskyPost(vm, item, record) {
+  if (!record) {
+    vm.body = { kind: "generic" };
+    return vm;
+  }
+  const did = didFromUri(item.uri);
+  const text = asNonEmptyString(record.text);
+  const { media, externalLink } = did ? bskyEmbedContent(record, did) : {};
+  if (media) vm.media = media;
+  if (externalLink) vm.externalLink = externalLink;
+  let body;
+  if (text) body = { kind: "text", text };
+  else if (vm.media) body = { kind: "media" };
+  else if (vm.externalLink) body = { kind: "link" };
+  else body = { kind: "generic" };
+  vm.body = body;
+  return vm;
+}
+function toStreamCardVM(item, options = {}) {
+  const verb = verbForCollection(item.collection);
+  const source = buildSource(item, options);
+  const record = asRecord(item.record);
+  const timestamp = (record ? asNonEmptyString(record.createdAt) : void 0) ?? item.indexedAt;
+  const vm = {
+    uri: item.uri,
+    cid: item.cid,
+    verb,
+    source,
+    tier: getActivityTier(item.collection),
+    timestamp,
+    title: buildTitle(verb, source.label)
+  };
+  const theme = readTheme(record);
+  if (theme) vm.theme = theme;
+  if (item.subject) {
+    vm.subject = { kind: "post", post: toStreamCardVM(item.subject, options) };
+  }
+  if (item.collection === "app.bsky.feed.post") {
+    return applyBskyPost(vm, item, record);
+  }
+  vm.body = { kind: "generic" };
+  return vm;
+}
+function toStreamCardVMs(items, options = {}) {
+  const out = [];
+  for (const item of items) {
+    if (isVisibleActivityItem(item.collection, item.record)) {
+      out.push(toStreamCardVM(item, options));
+    }
+  }
+  return out;
+}
+
 // src/logic/profile-completeness.ts
 var COMPLETENESS_MAX_SCORE = 6;
 function completenessScore(c) {
@@ -3217,8 +3523,8 @@ function encodeFeedCursor(cursor) {
 }
 function decodeFeedCursor(encoded) {
   const json = fromBase64Url(encoded);
-  const parsed2 = JSON.parse(json);
-  return FeedCursorSchema.parse(parsed2);
+  const parsed3 = JSON.parse(json);
+  return FeedCursorSchema.parse(parsed3);
 }
 var ProfileCertificationRecordSchema = zod.z.object({
   name: zod.z.string().min(1).refine(maxGraphemes(100)).max(1e3),
@@ -3432,9 +3738,10 @@ var ProfileVolunteeringRecordSchema = zod.z.object({
 });
 
 // src/index.ts
-var SIFA_SDK_VERSION = "0.12.8";
+var SIFA_SDK_VERSION = "0.12.9";
 
 exports.ACTIVITY_TIERS = ACTIVITY_TIERS;
+exports.ACTIVITY_VERBS = ACTIVITY_VERBS;
 exports.ACTIVITY_VISIBILITY_RULES = ACTIVITY_VISIBILITY_RULES;
 exports.ADULT_CONTENT_LABELS = ADULT_CONTENT_LABELS;
 exports.ALL_SECTIONS = ALL_SECTIONS;
@@ -3521,6 +3828,7 @@ exports.SECTION_LABELS = SECTION_LABELS;
 exports.SIFA_SDK_VERSION = SIFA_SDK_VERSION;
 exports.SKILL_CATEGORIES = SKILL_CATEGORIES;
 exports.STANDARD_PUBLISHER_ID = STANDARD_PUBLISHER_ID;
+exports.STREAM_VERBS = STREAM_VERBS;
 exports.SifaFeedItemSchema = SifaFeedItemSchema;
 exports.VERIFICATION_PROVIDERS = VERIFICATION_PROVIDERS;
 exports.WORKPLACE_TYPE_LABELS = WORKPLACE_TYPE_LABELS;
@@ -3558,6 +3866,7 @@ exports.formatRelativeTime = formatRelativeTime;
 exports.formatTimelineDate = formatTimelineDate;
 exports.getActivityTaxonomyVersion = getActivityTaxonomyVersion;
 exports.getActivityTier = getActivityTier;
+exports.getActivityVerbsVersion = getActivityVerbsVersion;
 exports.getAppCategoryIcon = getAppCategoryIcon;
 exports.getAppIdForCollection = getAppIdForCollection;
 exports.getArtifactLinkKindLabel = getArtifactLinkKindLabel;
@@ -3648,11 +3957,22 @@ exports.sortLanguagesByProficiency = sortLanguagesByProficiency;
 exports.sortPositions = sortPositions;
 exports.sortProjects = sortProjects;
 exports.sortPublications = sortPublications;
+exports.streamCardBodySchema = streamCardBodySchema;
+exports.streamCardSubjectSchema = streamCardSubjectSchema;
+exports.streamCardVMSchema = streamCardVMSchema;
+exports.streamExternalLinkSchema = streamExternalLinkSchema;
+exports.streamMediaSchema = streamMediaSchema;
+exports.streamSourceSchema = streamSourceSchema;
+exports.streamThemeSchema = streamThemeSchema;
+exports.streamVerbSchema = streamVerbSchema;
 exports.stripHtmlToText = stripHtmlToText;
 exports.strongRefSchema = strongRefSchema;
 exports.summarizePresentationDeliveries = summarizePresentationDeliveries;
+exports.toStreamCardVM = toStreamCardVM;
+exports.toStreamCardVMs = toStreamCardVMs;
 exports.truncateGraphemes = truncateGraphemes;
 exports.uriSchema = uriSchema;
+exports.verbForCollection = verbForCollection;
 exports.visibleItems = visibleItems;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map