dreaction-client-core 1.2.2 → 1.3.0

package/src/plugins/api-response.ts

@@ -1,4 +1,4 @@
-import type { DReactionCore, Plugin } from '../';
+import type { DReactionCore, Plugin } from '../types';
 
 /**
  * Sends API request/response information.

package/src/plugins/benchmark.ts

@@ -1,4 +1,4 @@
-import type { DReactionCore, Plugin } from '../';
+import type { DReactionCore, Plugin } from '../types';
 
 /**
  * Runs small high-unscientific benchmarks for you.

package/src/plugins/clear.ts

@@ -1,4 +1,4 @@
-import type { DReactionCore, Plugin } from '../';
+import type { DReactionCore, Plugin } from '../types';
 
 /**
  * Clears the dreaction server.

package/src/plugins/image.ts

@@ -1,4 +1,4 @@
-import type { DReactionCore, Plugin } from '../';
+import type { DReactionCore, Plugin } from '../types';
 
 export interface ImagePayload {
   uri: string;

package/src/plugins/index.ts

@@ -0,0 +1,26 @@
+import type { DReactionCore, PluginCreator } from '../types';
+import logger from './logger';
+import image from './image';
+import benchmark from './benchmark';
+import stateResponses from './state-responses';
+import apiResponse from './api-response';
+import clear from './clear';
+import issue from './issue';
+
+export { default as logger } from './logger';
+export { default as image } from './image';
+export { default as benchmark } from './benchmark';
+export { default as stateResponses } from './state-responses';
+export { default as apiResponse } from './api-response';
+export { default as clear } from './clear';
+export { default as issue } from './issue';
+
+export const corePlugins = [
+  image(),
+  logger(),
+  benchmark(),
+  stateResponses(),
+  apiResponse(),
+  clear(),
+  issue(),
+] satisfies PluginCreator<DReactionCore>[];

package/src/plugins/issue.ts

@@ -0,0 +1,25 @@
+import type { DReactionCore, Plugin, InferFeatures } from '../types';
+import { createPluginGuard } from '../utils/plugin-guard';
+
+/**
+ * Provides issue reporting feature
+ */
+const issue = () => (dreaction: DReactionCore) => {
+  return {
+    features: {
+      reportIssue: (id: string, name?: string, description?: string) => {
+        dreaction.send('report.issue', { id, name, description }, true);
+      },
+    },
+  } satisfies Plugin<DReactionCore>;
+};
+
+export default issue;
+
+export type IssuePlugin = ReturnType<typeof issue>;
+export type IssueFeatures = InferFeatures<ReturnType<typeof issue>>;
+
+const issueGuard = createPluginGuard<IssueFeatures>(['reportIssue'], 'issue');
+
+export const hasIssuePlugin = issueGuard.has;
+export const assertHasIssuePlugin = issueGuard.assert;

package/src/plugins/logger.ts

@@ -1,28 +1,29 @@
-import type { DReactionCore, Plugin, InferFeatures } from '../';
+import type { DReactionCore, Plugin, InferFeatures } from '../types';
+import { createPluginGuard } from '../utils/plugin-guard';
 
 /**
- * Provides 4 features for logging.  log & debug are the same.
+ * Provides logging features: log, info, debug, warn, error
  */
 const logger = () => (dreaction: DReactionCore) => {
   return {
     features: {
-      log: (...args) => {
-        const content = args && args.length === 1 ? args[0] : args;
+      log: (...args: any[]) => {
+        const content = args.length === 1 ? args[0] : args;
         dreaction.send('log', { level: 'debug', message: content }, false);
       },
-      info: (...args) => {
-        const content = args && args.length === 1 ? args[0] : args;
+      info: (...args: any[]) => {
+        const content = args.length === 1 ? args[0] : args;
         dreaction.send('log', { level: 'debug', message: content }, false);
       },
-      logImportant: (...args) => {
-        const content = args && args.length === 1 ? args[0] : args;
+      logImportant: (...args: any[]) => {
+        const content = args.length === 1 ? args[0] : args;
         dreaction.send('log', { level: 'debug', message: content }, true);
       },
       debug: (message, important = false) =>
         dreaction.send('log', { level: 'debug', message }, !!important),
       warn: (message) =>
         dreaction.send('log', { level: 'warn', message }, true),
-      error: (message, stack) =>
+      error: (message, stack?) =>
         dreaction.send('log', { level: 'error', message, stack }, true),
     },
   } satisfies Plugin<DReactionCore>;
@@ -31,35 +32,12 @@ const logger = () => (dreaction: DReactionCore) => {
 export default logger;
 
 export type LoggerPlugin = ReturnType<typeof logger>;
+export type LoggerFeatures = InferFeatures<ReturnType<typeof logger>>;
 
-export const hasLoggerPlugin = (
-  dreaction: DReactionCore
-): dreaction is DReactionCore &
-  InferFeatures<DReactionCore, ReturnType<typeof logger>> => {
-  return (
-    dreaction &&
-    'log' in dreaction &&
-    typeof dreaction.log === 'function' &&
-    'info' in dreaction &&
-    typeof dreaction.info === 'function' &&
-    'logImportant' in dreaction &&
-    typeof dreaction.logImportant === 'function' &&
-    'debug' in dreaction &&
-    typeof dreaction.debug === 'function' &&
-    'warn' in dreaction &&
-    typeof dreaction.warn === 'function' &&
-    'error' in dreaction &&
-    typeof dreaction.error === 'function'
-  );
-};
+const loggerGuard = createPluginGuard<LoggerFeatures>(
+  ['log', 'info', 'logImportant', 'debug', 'warn', 'error'],
+  'logger'
+);
 
-export const assertHasLoggerPlugin = (
-  dreaction: DReactionCore
-): asserts dreaction is DReactionCore &
-  InferFeatures<DReactionCore, ReturnType<typeof logger>> => {
-  if (!hasLoggerPlugin(dreaction)) {
-    throw new Error(
-      'This DReaction client has not had the logger plugin applied to it. Make sure that you add `use(logger())` before adding this plugin.'
-    );
-  }
-};
+export const hasLoggerPlugin = loggerGuard.has;
+export const assertHasLoggerPlugin = loggerGuard.assert;

package/src/plugins/state-responses.ts

@@ -5,7 +5,8 @@ import type {
   StateValuesChangePayload,
   StateValuesResponsePayload,
 } from 'dreaction-protocol';
-import type { DReactionCore, Plugin, InferFeatures } from '../';
+import type { DReactionCore, Plugin, InferFeatures } from '../types';
+import { createPluginGuard } from '../utils/plugin-guard';
 
 /**
  * Provides helper functions for send state responses.
@@ -36,40 +37,29 @@ const stateResponse = () => (dreaction: DReactionCore) => {
         changes.length > 0 &&
         dreaction.send('state.values.change', { changes }),
 
-      /** sends the state backup over to the server */
       stateBackupResponse: (state: StateBackupResponsePayload['state']) =>
         dreaction.send('state.backup.response', { state }),
     },
   } satisfies Plugin<DReactionCore>;
 };
 
-export type StateResponsePlugin = ReturnType<typeof stateResponse>;
-
 export default stateResponse;
 
-export const hasStateResponsePlugin = (
-  dreaction: DReactionCore
-): dreaction is DReactionCore &
-  InferFeatures<DReactionCore, ReturnType<typeof stateResponse>> =>
-  dreaction &&
-  'stateActionComplete' in dreaction &&
-  typeof dreaction.stateActionComplete === 'function' &&
-  'stateValuesResponse' in dreaction &&
-  typeof dreaction.stateValuesResponse === 'function' &&
-  'stateKeysResponse' in dreaction &&
-  typeof dreaction.stateKeysResponse === 'function' &&
-  'stateValuesChange' in dreaction &&
-  typeof dreaction.stateValuesChange === 'function' &&
-  'stateBackupResponse' in dreaction &&
-  typeof dreaction.stateBackupResponse === 'function';
+export type StateResponsePlugin = ReturnType<typeof stateResponse>;
+export type StateResponseFeatures = InferFeatures<
+  ReturnType<typeof stateResponse>
+>;
 
-export const assertHasStateResponsePlugin = (
-  dreaction: DReactionCore
-): asserts dreaction is DReactionCore &
-  InferFeatures<DReactionCore, ReturnType<typeof stateResponse>> => {
-  if (!hasStateResponsePlugin(dreaction)) {
-    throw new Error(
-      'This DReaction client has not had the state responses plugin applied to it. Make sure that you add `use(stateResponse())` before adding this plugin.'
-    );
-  }
-};
+const stateResponseGuard = createPluginGuard<StateResponseFeatures>(
+  [
+    'stateActionComplete',
+    'stateValuesResponse',
+    'stateKeysResponse',
+    'stateValuesChange',
+    'stateBackupResponse',
+  ],
+  'state responses'
+);
+
+export const hasStateResponsePlugin = stateResponseGuard.has;
+export const assertHasStateResponsePlugin = stateResponseGuard.assert;

package/src/types.ts

@@ -0,0 +1,127 @@
+import type {
+  Command,
+  CommandMap,
+  CustomCommandArg,
+  CustomCommandRegisterPayload,
+} from 'dreaction-protocol';
+import type { ClientOptions } from './client-options';
+
+// #region Basic Types
+type AnyFunction = (...args: any[]) => any;
+
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I
+) => void
+  ? I
+  : never;
+
+export interface DisplayConfig {
+  name: string;
+  value?: object | string | number | boolean | null | undefined;
+  preview?: string;
+  image?: string | { uri: string };
+  important?: boolean;
+}
+
+interface ArgTypeMap {
+  string: string;
+}
+
+export type CustomCommandArgs<Args extends CustomCommandArg[]> =
+  UnionToIntersection<
+    Args extends Array<infer U>
+      ? U extends CustomCommandArg
+        ? { [K in U as U['name']]: ArgTypeMap[U['type']] }
+        : never
+      : never
+  >;
+
+export interface CustomCommand<
+  Args extends CustomCommandArg[] = CustomCommandArg[]
+> extends Omit<CustomCommandRegisterPayload, 'id' | 'args'> {
+  id?: number;
+  handler: (args: CustomCommandArgs<Args>) => any | Promise<any>;
+  args?: Args;
+}
+// #endregion
+
+// #region Plugin Types
+export interface LifeCycleMethods {
+  onCommand?: (command: Command) => void;
+  onConnect?: () => void;
+  onDisconnect?: () => void;
+}
+
+export interface Plugin<Client> extends LifeCycleMethods {
+  features?: {
+    [key: string]: AnyFunction;
+  };
+  onPlugin?: (client: Client) => void;
+}
+
+export type PluginCreator<Client> = (client: Client) => Plugin<Client>;
+
+/**
+ * Extract features from a single PluginCreator
+ */
+type ExtractPluginFeatures<P> = P extends PluginCreator<any>
+  ? ReturnType<P> extends { features: infer F }
+    ? F
+    : {}
+  : {};
+
+/**
+ * Extract features type from a plugin or array of plugins.
+ * Supports:
+ * - Single PluginCreator: InferFeatures<typeof myPlugin>
+ * - Array of PluginCreators: InferFeatures<typeof plugins>
+ * - Legacy format: InferFeatures<Client, PluginCreator> (second param is the plugin)
+ */
+export type InferFeatures<ClientOrPlugin, LegacyPluginCreator = never> = [
+  LegacyPluginCreator
+] extends [never]
+  ? ClientOrPlugin extends PluginCreator<any>[]
+    ? UnionToIntersection<ExtractPluginFeatures<ClientOrPlugin[number]>>
+    : ExtractPluginFeatures<ClientOrPlugin>
+  : ExtractPluginFeatures<LegacyPluginCreator>;
+
+/**
+ * @deprecated Use InferFeatures instead
+ */
+export type InferFeaturesFromPlugins<
+  _Client,
+  Plugins extends PluginCreator<any>[]
+> = UnionToIntersection<ExtractPluginFeatures<Plugins[number]>>;
+// #endregion
+
+// #region Core Interface
+export interface DReactionCore {
+  connected: boolean;
+  isReady: boolean;
+  options: ClientOptions<this>;
+  plugins: Plugin<this>[];
+  startTimer: () => () => number;
+  close: () => this;
+  send: <Type extends keyof CommandMap>(
+    type: Type,
+    payload?: CommandMap[Type],
+    important?: boolean
+  ) => void;
+  display: (config: DisplayConfig) => void;
+  registerCustomCommand: <
+    Args extends CustomCommandArg[] = Exclude<CustomCommand['args'], undefined>
+  >(
+    config: CustomCommand<Args>
+  ) => () => void | ((config: string, optHandler?: () => void) => () => void);
+  configure: (
+    options?: ClientOptions<this>
+  ) => ClientOptions<this>['plugins'] extends PluginCreator<this>[]
+    ? this & InferFeatures<ClientOptions<this>['plugins']>
+    : this;
+  use: <P extends PluginCreator<this>>(
+    pluginCreator: P
+  ) => this & InferFeatures<P>;
+  connect: () => this;
+  waitForConnect: () => Promise<void>;
+}
+// #endregion

package/src/utils/plugin-guard.ts

@@ -0,0 +1,31 @@
+import type { DReactionCore } from '../types';
+
+type AnyFunction = (...args: any[]) => any;
+
+/**
+ * Create type guard functions for plugin features.
+ * Reduces boilerplate for hasXxxPlugin and assertHasXxxPlugin patterns.
+ */
+export function createPluginGuard<T extends Record<string, AnyFunction>>(
+  featureNames: (keyof T)[],
+  pluginName: string
+) {
+  const has = (client: DReactionCore): client is DReactionCore & T => {
+    return featureNames.every(
+      (name) => name in client && typeof (client as any)[name] === 'function'
+    );
+  };
+
+  const assert = (
+    client: DReactionCore
+  ): asserts client is DReactionCore & T => {
+    if (!has(client)) {
+      throw new Error(
+        `This DReaction client has not had the ${pluginName} plugin applied to it. ` +
+          `Make sure that you add the plugin before using these features.`
+      );
+    }
+  };
+
+  return { has, assert };
+}

package/src/plugins/repl.ts

@@ -1,63 +0,0 @@
-import type { DReactionCore, Plugin } from '../';
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-export type AcceptableRepls = object | Function | string | number;
-
-const repl = () => (dreaction: DReactionCore) => {
-  const myRepls: { [key: string]: AcceptableRepls } = {};
-  // let currentContext = null
-  return {
-    onCommand: ({ type, payload }) => {
-      if (type.substr(0, 5) !== 'repl.') return;
-
-      switch (type.substr(5)) {
-        case 'ls':
-          dreaction.send('repl.ls.response', Object.keys(myRepls));
-          break;
-        // case "cd":
-        //   const changeTo = myRepls.find(r => r.name === payload)
-        //   if (!changeTo) {
-        //     dreaction.send("repl.cd.response", "That REPL does not exist")
-        //     break
-        //   }
-        //   currentContext = payload
-        //   dreaction.send("repl.cd.response", `Change REPL to "${payload}"`)
-        //   break
-        case 'execute':
-          // if (!currentContext) {
-          //   dreaction.send(
-          //     "repl.execute.response",
-          //     "You must first select the REPL to use. Try 'ls'"
-          //   )
-          //   break
-          // }
-          // const currentRepl = myRepls.find(r => r.name === currentContext)
-          // if (!currentRepl) {
-          //   dreaction.send("repl.execute.response", "The selected REPL no longer exists.")
-          //   break
-          // }
-          dreaction.send(
-            'repl.execute.response',
-            function () {
-              return eval(payload); // eslint-disable-line no-eval
-            }.call(myRepls)
-          );
-          break;
-      }
-    },
-    features: {
-      repl: (name: string, value: AcceptableRepls) => {
-        if (!name) {
-          throw new Error('You must provide a name for your REPL');
-        }
-
-        if (myRepls[name]) {
-          throw new Error('You are already REPLing an item with that name');
-        }
-
-        myRepls[name] = value;
-      },
-    },
-  } satisfies Plugin<DReactionCore>;
-};
-export default repl;