@domino-sdk/relay 1.53.1 → 1.55.0

package/dist/vite.d.ts

@@ -28,5 +28,58 @@ declare function serverBoundary(options?: {
     }): void;
     resolveId(this: ResolveContext, source: string, importer: string | undefined, resolveOptions: Record<string, unknown>): Promise<null>;
 };
+/** Options for the app's own `cloudflare()` call from `@cloudflare/vite-plugin`. */
+type DominoCloudflareOptions = {
+    inspectorPort: false;
+    viteEnvironment: {
+        name: string;
+    };
+    /** Set only when serving: the `domino dev` variables, `""` when unset. */
+    config?: {
+        vars: Record<string, string>;
+    };
+};
+/** Vite's `server` settings for serving behind `domino dev`. */
+type DominoServerOptions = {
+    strictPort: true;
+    port: number;
+    allowedHosts: string[];
+    /** Set only behind a preview origin: hot reload over its HTTPS host. */
+    hmr?: {
+        protocol: "wss";
+        host: string;
+        clientPort: number;
+    };
+};
+/**
+ * The Vite settings a Domino-hosted Worker app needs, so `vite.config.ts`
+ * holds only the app's own plugins:
+ *
+ * ```ts
+ * export default defineConfig(({ command }) => {
+ *   const domino = dominoHosting({ command })
+ *
+ *   return {
+ *     plugins: [serverBoundary(), react(), cloudflare(domino.cloudflare)],
+ *     server: domino.server,
+ *   }
+ * })
+ * ```
+ *
+ * `cloudflare` builds the Worker in Vite's `server` environment and, when
+ * serving, forwards the variables `domino dev` sets to the local Worker. The
+ * app passes it to its own `cloudflare()` call, so the SDK does not depend on
+ * `@cloudflare/vite-plugin`; spread it to add options. `server` serves on
+ * `DOMINO_APP_PORT` (5173 by default) and, behind `DOMINO_PREVIEW_ORIGIN`,
+ * accepts that host and runs hot reload through it.
+ */
+declare function dominoHosting(options: {
+    command: "serve" | "build";
+    /** Where to read the variables. Defaults to `process.env`. */
+    env?: Record<string, string | undefined>;
+}): {
+    cloudflare: DominoCloudflareOptions;
+    server: DominoServerOptions;
+};
 
-export { serverBoundary };
+export { type DominoCloudflareOptions, type DominoServerOptions, dominoHosting, serverBoundary };

package/dist/vite.js

@@ -38,6 +38,41 @@ function serverBoundary(options = {}) {
     }
   };
 }
+var DEVELOPMENT_VARIABLES = [
+  "DOMINO_PARTICIPANT_API",
+  "DOMINO_PREVIEW_ORIGIN",
+  "DOMINO_LOCAL_API",
+  "DOMINO_DEV_CONTROL",
+  "DOMINO_MANAGEMENT_KEY",
+  "DOMINO_API_URL",
+  "DOMINO_ORGANIZATION",
+  "DOMINO_PROJECT",
+  "DOMINO_ENVIRONMENT"
+];
+function dominoHosting(options) {
+  const env = options.env ?? globalThis.process?.env ?? {};
+  const previewHost = env.DOMINO_PREVIEW_ORIGIN ? new URL(env.DOMINO_PREVIEW_ORIGIN).hostname : void 0;
+  return {
+    cloudflare: {
+      inspectorPort: false,
+      viteEnvironment: { name: "server" },
+      ...options.command === "serve" ? {
+        config: {
+          vars: Object.fromEntries(
+            DEVELOPMENT_VARIABLES.map((name) => [name, env[name] ?? ""])
+          )
+        }
+      } : {}
+    },
+    server: {
+      strictPort: true,
+      port: Number(env.DOMINO_APP_PORT ?? 5173),
+      allowedHosts: previewHost ? [previewHost] : [],
+      ...previewHost ? { hmr: { protocol: "wss", host: previewHost, clientPort: 443 } } : {}
+    }
+  };
+}
 export {
+  dominoHosting,
   serverBoundary
 };

package/dist/{x-BfQcsDp0.d.ts → x-1czZFVUW.d.ts}

@@ -1,5 +1,5 @@
 import * as z from 'zod';
-import { _ as PhotoResult } from './schema-BJ9bOgpN.js';
+import { a8 as PhotoResult } from './schema-C4m9RhCR.js';
 
 /**
  * Quest code names an image; the platform fetches, decodes and pins it. No bytes or URLs cross the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domino-sdk/relay",
-  "version": "1.53.1",
+  "version": "1.55.0",
   "type": "module",
   "exports": {
     ".": {
@@ -93,7 +93,8 @@
   "files": [
     "dist",
     "build.mjs",
-    "build.d.mts"
+    "build.d.mts",
+    "CHANGELOG.md"
   ],
   "description": "SDK for authoring quests and integrating Domino Relay",
   "scripts": {

package/dist/chunk-2NUD237O.js

@@ -1,102 +0,0 @@
-import {
-  accountConnectionSchema
-} from "./chunk-IELNFM3V.js";
-
-// src/telegram.ts
-import * as z from "zod";
-var telegramSignInMethodsSchema = z.object({
-  /** Telegram Login, the OpenID Connect sign-in Domino configures for the platform. */
-  login: z.boolean(),
-  /** Mini App sign-in, which the project enables in Console with its bot's ID. */
-  miniApp: z.boolean()
-});
-var telegramAccountConnectionSchema = accountConnectionSchema.extend({
-  provider: z.literal("telegram")
-});
-var telegramInitDataSchema = z.string().min(1, "Pass the Mini App's Telegram.WebApp.initData").max(8192);
-var telegramMiniAppSignInSchema = z.object({
-  initData: telegramInitDataSchema,
-  mode: z.enum(["sign-in", "connect"])
-}).strict();
-var telegramChatIdSchema = z.string().regex(
-  /^-?[1-9][0-9]{0,19}$/,
-  "Use the chat's numeric ID, such as -1001234567890"
-);
-var telegramChatSchema = z.object({
-  /** The numeric chat ID, as a string. */
-  id: telegramChatIdSchema,
-  /** `group`, `supergroup` or `channel`; a later Telegram may add others. */
-  type: z.string(),
-  title: z.string(),
-  /** The public @username, without the @, or null for a private chat. */
-  username: z.string().nullable(),
-  status: z.string(),
-  issue: z.string().nullable(),
-  connectedAt: z.number()
-});
-var telegramChatsSchema = z.object({
-  configured: z.boolean(),
-  /** Domino's bot, the one operators add to their chats. */
-  bot: z.object({ username: z.string() }).nullable(),
-  chats: z.array(telegramChatSchema)
-});
-var telegramChatConnectionSchema = z.object({
-  url: z.string(),
-  expiresAt: z.number()
-});
-var telegramMemberInputSchema = z.object({
-  chat: z.string().regex(
-    /^(-?[1-9][0-9]{0,19}|@[A-Za-z][A-Za-z0-9_]{3,31})$/,
-    "Name a chat the project connected, by its numeric ID or @username"
-  )
-}).strict();
-var telegramChatMemberSchema = z.object({
-  /** The numeric Telegram user ID. */
-  userId: z.string(),
-  username: z.string().nullable(),
-  status: z.custom(
-    (value) => typeof value === "string"
-  ),
-  /** Whether they are in the chat now: a creator, administrator, member, or restricted member. */
-  isMember: z.boolean(),
-  /** Whether they are its creator or an administrator. */
-  isAdmin: z.boolean(),
-  /** When a paid subscription or a restriction ends, epoch milliseconds; null when it does not. */
-  untilDate: z.number().nullable()
-});
-var telegramReactionsNamespace = "telegram-reactions";
-var telegramReactionDataSchema = z.object({
-  /** The chat's numeric ID, as a string. */
-  chatId: z.string(),
-  /** `group` or `supergroup`: channel reactions are anonymous and never recorded. */
-  chatType: z.string(),
-  messageId: z.number(),
-  /** `emoji`, `custom_emoji` or `paid`. */
-  reactionType: z.string(),
-  /** The emoji, such as "❤", for an `emoji` reaction; null otherwise. */
-  emoji: z.string().nullable(),
-  /** The custom emoji's ID for a `custom_emoji` reaction; null otherwise. */
-  customEmojiId: z.string().nullable(),
-  /**
-   * `creator` or `administrator` for one of the chat's administrators, read at most ten minutes
-   * before Relay recorded the reaction; `member` for anyone else.
-   */
-  reactorStatus: z.string(),
-  /** Whether the reactor was the chat's creator or an administrator then. */
-  reactorIsAdmin: z.boolean()
-});
-
-export {
-  telegramSignInMethodsSchema,
-  telegramAccountConnectionSchema,
-  telegramInitDataSchema,
-  telegramMiniAppSignInSchema,
-  telegramChatIdSchema,
-  telegramChatSchema,
-  telegramChatsSchema,
-  telegramChatConnectionSchema,
-  telegramMemberInputSchema,
-  telegramChatMemberSchema,
-  telegramReactionsNamespace,
-  telegramReactionDataSchema
-};