@domino-sdk/relay 1.60.0 → 1.62.0

package/dist/chunk-D26YNACF.js

@@ -0,0 +1,320 @@
+import {
+  badgeSchema,
+  pointLedgerReferenceSchema
+} from "./chunk-WSBYWVTZ.js";
+import {
+  authoringIdentityShape,
+  entitlementSchema,
+  identifier,
+  mediaUrlSchema,
+  memberProgressSchema,
+  pageCursorSchema,
+  prerequisiteSchema,
+  publishedReleaseSchema,
+  questPresentationContentSchema,
+  questScaleLimits,
+  responseShape,
+  retryCooldownMsSchema,
+  reviewModeSchema,
+  sdkRuntimeReferenceSchema,
+  settingsValuesSchema,
+  storedQuestDescriptionSchema,
+  storedReviewModeSchema,
+  tieredRewardReferenceSchema
+} from "./chunk-MK425RXJ.js";
+
+// src/participant-activity.ts
+import * as z from "zod";
+var base = { id: z.string(), at: z.number() };
+var attempt = {
+  ...base,
+  quest: z.string(),
+  attempt: z.string(),
+  completion: z.string().nullable()
+};
+var kinds = [
+  "attempt.accepted",
+  "attempt.rejected",
+  "attempt.review",
+  "points.awarded",
+  "entitlement.granted",
+  "entitlement.collected",
+  "delivery.updated",
+  "referral.qualified"
+];
+var knownRelayEventSchema = z.discriminatedUnion("kind", [
+  z.object({ ...attempt, kind: z.literal("attempt.accepted") }),
+  z.object({ ...attempt, kind: z.literal("attempt.rejected") }),
+  z.object({ ...attempt, kind: z.literal("attempt.review") }),
+  z.object({
+    ...base,
+    kind: z.literal("points.awarded"),
+    entry: z.string(),
+    ledger: z.string(),
+    amount: z.number(),
+    quest: z.string().nullable(),
+    completion: z.string().nullable()
+  }),
+  z.object({
+    ...base,
+    kind: z.literal("entitlement.granted"),
+    entitlement: z.string(),
+    tier: z.string(),
+    status: z.string()
+  }),
+  z.object({
+    ...base,
+    kind: z.literal("entitlement.collected"),
+    entitlement: z.string()
+  }),
+  z.object({
+    ...base,
+    kind: z.literal("delivery.updated"),
+    delivery: z.string(),
+    quest: z.string(),
+    completion: z.string(),
+    status: z.string()
+  }),
+  z.object({
+    ...base,
+    kind: z.literal("referral.qualified"),
+    program: z.string()
+  })
+]);
+var relayEventSchema = z.union([
+  knownRelayEventSchema,
+  z.object({
+    ...base,
+    kind: z.string().refine((kind) => !kinds.includes(kind))
+  }).catchall(z.json()).transform(({ kind, ...event }) => ({
+    ...event,
+    kind: "unknown",
+    reportedKind: kind
+  }))
+]);
+var participantActivityQuerySchema = z.object({
+  cursor: pageCursorSchema.optional(),
+  /** `latest` answers no events and the cursor of the newest one, to follow only what comes next. */
+  start: z.literal("latest").optional(),
+  limit: z.number().int().min(1).max(100).default(50)
+}).strict().refine((query) => !(query.cursor && query.start), {
+  message: "Pass either cursor or start, not both"
+});
+var participantActivitySchema = z.object({
+  member: z.string(),
+  items: z.array(relayEventSchema),
+  /**
+   * Never null: the feed has no last page, so an empty page still answers the cursor to read
+   * from next. A loop over it, such as `paginate`, stops on its own condition, such as an empty
+   * page or a count.
+   */
+  nextCursor: pageCursorSchema
+});
+
+// src/catalog.ts
+import * as z2 from "zod";
+var interactionSchema = z2.enum([
+  "photo",
+  "text",
+  "url",
+  "quiz",
+  "claim",
+  "staff",
+  "automatic"
+]);
+function questInteraction(trigger) {
+  return trigger.kind === "automatic" ? "automatic" : trigger.actor === "staff" ? "staff" : trigger.input === "none" ? "claim" : trigger.input;
+}
+var questTypeVersionSchema = z2.object({
+  archivedAt: z2.number().int().nonnegative().nullable().optional(),
+  key: identifier.optional(),
+  id: identifier,
+  version: identifier,
+  code: z2.string(),
+  /** The SDK runtime `code` imports. Absent, the code bundles its own SDK. */
+  runtime: sdkRuntimeReferenceSchema.optional(),
+  definition: storedQuestDescriptionSchema,
+  provider: storedReviewModeSchema,
+  createdAt: z2.number()
+});
+var collectionSlotSchema = z2.object({
+  archivedAt: z2.number().int().nonnegative().nullable().optional(),
+  id: identifier,
+  key: identifier.optional(),
+  title: z2.string().trim().min(1).max(120),
+  description: z2.string().max(4e3).optional(),
+  image: mediaUrlSchema.optional(),
+  imageAlt: z2.string().max(500).optional()
+});
+var collectionSlotDeclarationSchema = collectionSlotSchema.omit({ id: true, archivedAt: true }).extend(authoringIdentityShape).strict();
+var questCollectionSchema = collectionSlotSchema.extend({
+  quests: z2.array(identifier).max(100).refine(
+    (v) => new Set(v).size === v.length,
+    "A collection can contain a quest only once"
+  )
+});
+var questInstanceSchema = z2.object({
+  badges: z2.array(identifier).max(10).refine(
+    (items) => new Set(items).size === items.length,
+    "Choose each badge once"
+  ).optional(),
+  id: identifier,
+  title: z2.string().trim().min(1).max(120),
+  typeVersion: identifier,
+  presentation: questPresentationContentSchema.optional(),
+  settings: settingsValuesSchema,
+  requires: z2.array(prerequisiteSchema).max(30),
+  /**
+   * Milliseconds a member waits after a rejected attempt before submitting again, or `null` for
+   * no cooldown. Omitted: the quest type's own `retryCooldownMs`.
+   */
+  retryCooldownMs: retryCooldownMsSchema.nullable().optional(),
+  /**
+   * Milliseconds a member waits after an accepted completion before submitting again, or `null`
+   * for no cooldown. Omitted: the quest type's own `completionCooldownMs`.
+   */
+  completionCooldownMs: retryCooldownMsSchema.nullable().optional(),
+  status: z2.enum(["active", "paused", "archived"])
+}).strict();
+var questDraftChangesSchema = z2.object({
+  quests: z2.array(
+    questInstanceSchema.extend({ expectedRelease: identifier.nullable() })
+  ).max(questScaleLimits.quests),
+  collections: z2.array(questCollectionSchema.omit({ archivedAt: true }).strict()).max(questScaleLimits.collections)
+}).strict();
+var draftBase = z2.object({
+  id: identifier,
+  revision: z2.number().int().positive(),
+  baseRevision: z2.number().int().nonnegative(),
+  changes: questDraftChangesSchema
+});
+var questDraftSchema = responseShape(
+  z2.discriminatedUnion("status", [
+    draftBase.extend({ status: z2.literal("draft") }),
+    draftBase.extend({
+      status: z2.literal("published"),
+      releaseIds: z2.array(identifier)
+    })
+  ])
+);
+var questCatalogSchema = responseShape(
+  z2.object({
+    revision: z2.number().int().nonnegative(),
+    types: z2.array(questTypeVersionSchema),
+    collections: z2.array(questCollectionSchema),
+    quests: z2.array(questInstanceSchema),
+    drafts: z2.array(questDraftSchema),
+    releases: z2.array(publishedReleaseSchema).default([]),
+    supportedInteractions: z2.array(interactionSchema)
+  })
+);
+var catalogDeploymentSchema = z2.object({
+  expectedRevision: z2.number().int().nonnegative(),
+  types: z2.array(
+    z2.object({
+      code: z2.string().min(1).max(1e6),
+      runtime: sdkRuntimeReferenceSchema.optional(),
+      provider: reviewModeSchema
+    })
+  ).max(questScaleLimits.questTypes).default([]),
+  collections: z2.array(collectionSlotDeclarationSchema).max(questScaleLimits.collections).default([]),
+  supportedInteractions: z2.array(interactionSchema).min(1).optional()
+}).strict();
+var catalogDeploymentPreviewSchema = responseShape(
+  z2.object({
+    revision: z2.number().int().nonnegative(),
+    types: z2.array(questTypeVersionSchema),
+    collections: z2.array(collectionSlotSchema),
+    supportedInteractions: z2.array(interactionSchema)
+  })
+);
+var saveQuestDraftSchema = z2.object({
+  id: identifier.optional(),
+  actionId: identifier,
+  expectedRevision: z2.number().int().nonnegative(),
+  baseRevision: z2.number().int().nonnegative(),
+  changes: questDraftChangesSchema
+}).strict();
+var publishQuestDraftSchema = z2.object({ id: identifier, expectedRevision: z2.number().int().positive() }).strict();
+var questRewardViewSchema = z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("points"),
+    label: z2.string(),
+    amount: z2.number().int().nonnegative(),
+    ledger: pointLedgerReferenceSchema
+  }),
+  z2.object({
+    kind: z2.literal("tier"),
+    label: z2.string(),
+    reward: tieredRewardReferenceSchema.extend({
+      title: z2.string(),
+      badge: badgeSchema.optional(),
+      /** The group the reward adds the member to: its key and the title the quest names it by. */
+      group: z2.object({ key: identifier, title: z2.string() }).optional()
+    }),
+    tier: identifier
+  }),
+  z2.object({ kind: z2.literal("integration"), label: z2.string() })
+]);
+var questViewSchema = responseShape(
+  memberProgressSchema.shape.quests.element.extend({
+    release: identifier,
+    interaction: interactionSchema,
+    lifecycle: z2.enum(["active", "paused", "archived"]),
+    rewards: z2.array(questRewardViewSchema)
+  })
+);
+var collectionViewSchema = z2.object({
+  key: identifier.optional(),
+  id: identifier,
+  title: z2.string(),
+  description: z2.string().optional(),
+  image: mediaUrlSchema.optional(),
+  imageAlt: z2.string().optional(),
+  quests: z2.array(questViewSchema)
+});
+var questExperienceSchema = responseShape(
+  z2.object({
+    entitlements: z2.array(entitlementSchema).default([]),
+    member: identifier,
+    quests: z2.array(questViewSchema),
+    collections: z2.array(collectionViewSchema)
+  })
+);
+var questPublicationPreviewSchema = responseShape(
+  z2.object({
+    draft: questDraftSchema,
+    releases: z2.array(publishedReleaseSchema),
+    affectedCollections: z2.array(questCollectionSchema)
+  })
+);
+var allocateQuestSchema = z2.object({ actionId: identifier }).strict();
+var allocatedQuestSchema = z2.object({ id: identifier });
+
+export {
+  knownRelayEventSchema,
+  relayEventSchema,
+  participantActivityQuerySchema,
+  participantActivitySchema,
+  interactionSchema,
+  questInteraction,
+  questTypeVersionSchema,
+  collectionSlotSchema,
+  collectionSlotDeclarationSchema,
+  questCollectionSchema,
+  questInstanceSchema,
+  questDraftChangesSchema,
+  questDraftSchema,
+  questCatalogSchema,
+  catalogDeploymentSchema,
+  catalogDeploymentPreviewSchema,
+  saveQuestDraftSchema,
+  publishQuestDraftSchema,
+  questRewardViewSchema,
+  questViewSchema,
+  collectionViewSchema,
+  questExperienceSchema,
+  questPublicationPreviewSchema,
+  allocateQuestSchema,
+  allocatedQuestSchema
+};

package/dist/{chunk-KUPVQXUJ.js → chunk-E6IKQHTX.js}

@@ -4,10 +4,10 @@ import {
   imageFieldsSchema,
   imageInspectionSchema,
   imageSightingsSchema
-} from "./chunk-YOAPPIWN.js";
+} from "./chunk-QYPMPWVX.js";
 import {
   photoResultSchema
-} from "./chunk-GBSDAD3N.js";
+} from "./chunk-MK425RXJ.js";
 
 // src/image-results.ts
 import * as z from "zod";

package/dist/chunk-FWLQ5XCS.js

@@ -0,0 +1,21 @@
+// src/telegram-browser.ts
+function miniAppInitData() {
+  const scope = globalThis;
+  const fromScript = scope.Telegram?.WebApp?.initData;
+  if (typeof fromScript === "string" && fromScript.length > 0) {
+    return fromScript;
+  }
+  const hash = scope.location?.hash;
+  if (!hash) {
+    return null;
+  }
+  return new URLSearchParams(hash.replace(/^#/, "")).get("tgWebAppData") || null;
+}
+function telegramMiniAppInitData() {
+  return miniAppInitData();
+}
+
+export {
+  miniAppInitData,
+  telegramMiniAppInitData
+};