spectrum-ts 0.2.2 → 0.4.0

package/src/platform/define.ts

@@ -1,308 +0,0 @@
-import type z from "zod";
-import type { ContentBuilder } from "../types/content";
-import type { Message } from "../types/message";
-import type { Space } from "../types/space";
-import type {
-  AnyPlatformDef,
-  Platform,
-  PlatformDef,
-  PlatformInstance,
-  PlatformMessage,
-  PlatformProviderConfig,
-  PlatformSpace,
-  PlatformUser,
-  ProviderMessage,
-  SpectrumLike,
-} from "./types";
-
-function createPlatformInstance<
-  Def extends AnyPlatformDef,
-  _Client,
-  _ConfigSchema extends z.ZodType<object>,
->(
-  def: Def,
-  runtime: { client: unknown; config: unknown }
-): PlatformInstance<Def> {
-  const isPlatformUser = (value: unknown): value is PlatformUser<Def> => {
-    return (
-      typeof value === "object" &&
-      value !== null &&
-      "__platform" in value &&
-      (value as { __platform?: unknown }).__platform === def.name
-    );
-  };
-
-  const normalizeSpaceArgs = (
-    args: unknown[]
-  ): { users: PlatformUser<Def>[]; params: unknown } => {
-    if (args.length === 0) {
-      return { users: [], params: undefined };
-    }
-
-    const [first, ...rest] = args;
-    if (Array.isArray(first)) {
-      return {
-        users: first as PlatformUser<Def>[],
-        params: rest[0],
-      };
-    }
-
-    if (!isPlatformUser(first)) {
-      return {
-        users: [],
-        params: first,
-      };
-    }
-
-    const last = args.at(-1);
-    if (last !== undefined && !isPlatformUser(last)) {
-      return {
-        users: args.slice(0, -1) as PlatformUser<Def>[],
-        params: last,
-      };
-    }
-
-    return {
-      users: args as PlatformUser<Def>[],
-      params: undefined,
-    };
-  };
-
-  const base = {
-    async user(userID: string) {
-      const resolved = await def.user.resolve({
-        input: { userID },
-        client: runtime.client as _Client,
-        config: runtime.config as z.infer<_ConfigSchema>,
-      });
-      return {
-        ...resolved,
-        __platform: def.name,
-      } as PlatformUser<Def>;
-    },
-
-    async space(...args: unknown[]) {
-      const { users, params } = normalizeSpaceArgs(args);
-      let parsedParams = params;
-      if (params !== undefined && def.space.params) {
-        parsedParams = def.space.params.parse(params);
-      }
-      const resolved = await def.space.resolve({
-        input: { users, params: parsedParams },
-        client: runtime.client as _Client,
-        config: runtime.config as z.infer<_ConfigSchema>,
-      });
-      const parsedSpace = def.space.schema
-        ? def.space.schema.parse(resolved)
-        : resolved;
-      const spaceRef = {
-        id: parsedSpace.id,
-        __platform: def.name,
-      };
-      const typingCtx = {
-        space: spaceRef,
-        client: runtime.client as _Client,
-        config: runtime.config as z.infer<_ConfigSchema>,
-      };
-      return {
-        ...parsedSpace,
-        ...spaceRef,
-        send: async (...content: [ContentBuilder, ...ContentBuilder[]]) => {
-          const built = await Promise.all(content.map((c) => c.build()));
-          await def.actions.send({
-            ...typingCtx,
-            content: built,
-          });
-        },
-        startTyping: async () => {
-          await def.actions.startTyping?.(typingCtx);
-        },
-        stopTyping: async () => {
-          await def.actions.stopTyping?.(typingCtx);
-        },
-        responding: async <T>(fn: () => T | Promise<T>): Promise<T> => {
-          await def.actions.startTyping?.(typingCtx);
-          try {
-            return await fn();
-          } finally {
-            await def.actions.stopTyping?.(typingCtx).catch(() => {});
-          }
-        },
-      } as PlatformSpace<Def>;
-    },
-  };
-
-  // Add flat event properties for custom events (non-messages)
-  const eventProperties: Record<string, AsyncIterable<unknown>> = {};
-  for (const eventName of Object.keys(def.events)) {
-    if (eventName === "messages") {
-      continue;
-    }
-    const producer = def.events[eventName] as
-      | ((ctx: { client: unknown; config: unknown }) => AsyncIterable<unknown>)
-      | undefined;
-    if (producer) {
-      eventProperties[eventName] = producer({
-        client: runtime.client,
-        config: runtime.config,
-      });
-    }
-  }
-
-  return Object.assign(base, eventProperties) as PlatformInstance<Def>;
-}
-
-export function definePlatform<
-  _Name extends string,
-  _ConfigSchema extends z.ZodType<object>,
-  _UserSchema extends z.ZodType<object> | undefined,
-  _SpaceSchema extends z.ZodType<object> | undefined,
-  _SpaceParamsSchema extends z.ZodType<object> | undefined,
-  _Client,
-  _ResolvedUser extends { id: string },
-  _ResolvedSpace extends { id: string },
-  _MessageSchema extends z.ZodType<object> | undefined = undefined,
-  _MessageType extends ProviderMessage<
-    _ResolvedUser,
-    _ResolvedSpace,
-    _MessageSchema extends z.ZodType<object>
-      ? z.infer<_MessageSchema>
-      : Record<never, never>
-  > = ProviderMessage<
-    _ResolvedUser,
-    _ResolvedSpace,
-    _MessageSchema extends z.ZodType<object>
-      ? z.infer<_MessageSchema>
-      : Record<never, never>
-  >,
-  _Events extends {
-    messages: (ctx: {
-      client: _Client;
-      config: z.infer<_ConfigSchema>;
-    }) => AsyncIterable<_MessageType>;
-  } = {
-    messages: (ctx: {
-      client: _Client;
-      config: z.infer<_ConfigSchema>;
-    }) => AsyncIterable<_MessageType>;
-  },
-  _Static extends Record<string, unknown> = Record<never, never>,
->(
-  name: _Name,
-  def: Omit<
-    PlatformDef<
-      _Name,
-      _ConfigSchema,
-      _UserSchema,
-      _SpaceSchema,
-      _SpaceParamsSchema,
-      _Client,
-      _ResolvedUser,
-      _ResolvedSpace,
-      _MessageSchema,
-      _MessageType,
-      _Events
-    >,
-    "name"
-  > & { static?: _Static }
-): Platform<
-  PlatformDef<
-    _Name,
-    _ConfigSchema,
-    _UserSchema,
-    _SpaceSchema,
-    _SpaceParamsSchema,
-    _Client,
-    _ResolvedUser,
-    _ResolvedSpace,
-    _MessageSchema,
-    _MessageType,
-    _Events
-  >
-> &
-  Readonly<_Static> {
-  type Def = PlatformDef<
-    _Name,
-    _ConfigSchema,
-    _UserSchema,
-    _SpaceSchema,
-    _SpaceParamsSchema,
-    _Client,
-    _ResolvedUser,
-    _ResolvedSpace,
-    _MessageSchema,
-    _MessageType,
-    _Events
-  >;
-
-  const fullDef = { name, ...def };
-
-  const platformCache = new WeakMap<SpectrumLike, PlatformInstance<Def>>();
-
-  const narrowSpectrum = (spectrum: SpectrumLike) => {
-    const cached = platformCache.get(spectrum);
-    if (cached) {
-      return cached;
-    }
-
-    const runtime = spectrum.__internal.platforms.get(name);
-    if (!runtime) {
-      throw new Error(`Platform "${name}" is not registered`);
-    }
-
-    const instance = createPlatformInstance<Def, _Client, _ConfigSchema>(
-      fullDef as Def & AnyPlatformDef,
-      runtime
-    );
-    platformCache.set(spectrum, instance);
-    return instance;
-  };
-
-  const narrowSpace = (input: Space) => {
-    if (input.__platform !== name) {
-      throw new Error(
-        `Expected space from "${name}", got "${input.__platform}"`
-      );
-    }
-    return input as PlatformSpace<Def>;
-  };
-
-  const narrowMessage = (input: Message) => {
-    if (input.platform !== name) {
-      throw new Error(
-        `Expected message from "${name}", got "${input.platform}"`
-      );
-    }
-    return input as PlatformMessage<Def>;
-  };
-
-  const narrower = ((input: SpectrumLike | Space | Message) => {
-    if ("__providers" in input && "__internal" in input) {
-      return narrowSpectrum(input as SpectrumLike);
-    }
-    if ("__platform" in input && "send" in input) {
-      return narrowSpace(input as Space);
-    }
-    if ("platform" in input && "sender" in input && "space" in input) {
-      return narrowMessage(input as Message);
-    }
-    throw new Error("Invalid input to platform narrowing function");
-  }) as Platform<Def>;
-
-  narrower.config = (config?: z.input<_ConfigSchema>) => {
-    const resolvedConfig = config ?? {};
-    return {
-      __tag: "PlatformProviderConfig" as const,
-      __def: undefined as unknown as Def,
-      __name: name,
-      config: resolvedConfig,
-      __definition: fullDef as AnyPlatformDef,
-    } satisfies PlatformProviderConfig<Def> as PlatformProviderConfig<Def>;
-  };
-
-  if (def.static) {
-    Object.assign(narrower, def.static);
-  }
-
-  return narrower as Platform<Def> & Readonly<_Static>;
-}