dreaction-client-core 1.0.0

package/src/plugins/clear.ts

@@ -0,0 +1,14 @@
+import type { DReactionCore, Plugin } from '../';
+
+/**
+ * Clears the reactotron server.
+ */
+const clear = () => (reactotron: DReactionCore) => {
+  return {
+    features: {
+      clear: () => reactotron.send('clear'),
+    },
+  } satisfies Plugin<DReactionCore>;
+};
+
+export default clear;

package/src/plugins/image.ts

@@ -0,0 +1,34 @@
+import type { DReactionCore, Plugin } from '../';
+
+export interface ImagePayload {
+  uri: string;
+  preview: string;
+  caption?: string;
+  width?: number;
+  height?: number;
+  filename?: string;
+}
+
+/**
+ * Provides an image.
+ */
+const image = () => (reactotron: DReactionCore) => {
+  return {
+    features: {
+      // expanded just to show the specs
+      image: (payload: ImagePayload) => {
+        const { uri, preview, filename, width, height, caption } = payload;
+        return reactotron.send('image', {
+          uri,
+          preview,
+          filename,
+          width,
+          height,
+          caption,
+        });
+      },
+    },
+  } satisfies Plugin<DReactionCore>;
+};
+
+export default image;

package/src/plugins/logger.ts

@@ -0,0 +1,59 @@
+import type { DReactionCore, Plugin, InferFeatures } from '../';
+
+/**
+ * Provides 4 features for logging.  log & debug are the same.
+ */
+const logger = () => (dreaction: DReactionCore) => {
+  return {
+    features: {
+      log: (...args) => {
+        const content = args && 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;
+        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) =>
+        dreaction.send('log', { level: 'error', message, stack }, true),
+    },
+  } satisfies Plugin<DReactionCore>;
+};
+
+export default logger;
+
+export type LoggerPlugin = 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' &&
+    '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'
+  );
+};
+
+export const assertHasLoggerPlugin = (
+  dreaction: DReactionCore
+): asserts dreaction is DReactionCore &
+  InferFeatures<DReactionCore, ReturnType<typeof logger>> => {
+  if (!hasLoggerPlugin(dreaction)) {
+    throw new Error(
+      'This Reactotron client has not had the logger plugin applied to it. Make sure that you add `use(logger())` before adding this plugin.'
+    );
+  }
+};

package/src/plugins/repl.ts

@@ -0,0 +1,63 @@
+import type { DReactionCore, Plugin } from '../';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type AcceptableRepls = object | Function | string | number;
+
+const repl = () => (reactotron: 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':
+          reactotron.send('repl.ls.response', Object.keys(myRepls));
+          break;
+        // case "cd":
+        //   const changeTo = myRepls.find(r => r.name === payload)
+        //   if (!changeTo) {
+        //     reactotron.send("repl.cd.response", "That REPL does not exist")
+        //     break
+        //   }
+        //   currentContext = payload
+        //   reactotron.send("repl.cd.response", `Change REPL to "${payload}"`)
+        //   break
+        case 'execute':
+          // if (!currentContext) {
+          //   reactotron.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) {
+          //   reactotron.send("repl.execute.response", "The selected REPL no longer exists.")
+          //   break
+          // }
+          reactotron.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;

package/src/plugins/state-responses.ts

@@ -0,0 +1,75 @@
+import type {
+  StateActionCompletePayload,
+  StateBackupResponsePayload,
+  StateKeysResponsePayload,
+  StateValuesChangePayload,
+  StateValuesResponsePayload,
+} from 'dreaction-protocol';
+import type { DReactionCore, Plugin, InferFeatures } from '../';
+
+/**
+ * Provides helper functions for send state responses.
+ */
+const stateResponse = () => (reactotron: DReactionCore) => {
+  return {
+    features: {
+      stateActionComplete: (
+        name: StateActionCompletePayload['name'],
+        action: StateActionCompletePayload['action'],
+        important = false
+      ) =>
+        reactotron.send('state.action.complete', { name, action }, !!important),
+
+      stateValuesResponse: (
+        path: StateValuesResponsePayload['path'],
+        value: StateValuesResponsePayload['value'],
+        valid: StateValuesResponsePayload['value'] = true
+      ) => reactotron.send('state.values.response', { path, value, valid }),
+
+      stateKeysResponse: (
+        path: StateKeysResponsePayload['path'],
+        keys: StateKeysResponsePayload['keys'],
+        valid: StateKeysResponsePayload['valid'] = true
+      ) => reactotron.send('state.keys.response', { path, keys, valid }),
+
+      stateValuesChange: (changes: StateValuesChangePayload['changes']) =>
+        changes.length > 0 &&
+        reactotron.send('state.values.change', { changes }),
+
+      /** sends the state backup over to the server */
+      stateBackupResponse: (state: StateBackupResponsePayload['state']) =>
+        reactotron.send('state.backup.response', { state }),
+    },
+  } satisfies Plugin<DReactionCore>;
+};
+
+export type StateResponsePlugin = ReturnType<typeof stateResponse>;
+
+export default stateResponse;
+
+export const hasStateResponsePlugin = (
+  reactotron: DReactionCore
+): reactotron is DReactionCore &
+  InferFeatures<DReactionCore, ReturnType<typeof stateResponse>> =>
+  reactotron &&
+  'stateActionComplete' in reactotron &&
+  typeof reactotron.stateActionComplete === 'function' &&
+  'stateValuesResponse' in reactotron &&
+  typeof reactotron.stateValuesResponse === 'function' &&
+  'stateKeysResponse' in reactotron &&
+  typeof reactotron.stateKeysResponse === 'function' &&
+  'stateValuesChange' in reactotron &&
+  typeof reactotron.stateValuesChange === 'function' &&
+  'stateBackupResponse' in reactotron &&
+  typeof reactotron.stateBackupResponse === 'function';
+
+export const assertHasStateResponsePlugin = (
+  reactotron: DReactionCore
+): asserts reactotron is DReactionCore &
+  InferFeatures<DReactionCore, ReturnType<typeof stateResponse>> => {
+  if (!hasStateResponsePlugin(reactotron)) {
+    throw new Error(
+      'This Reactotron client has not had the state responses plugin applied to it. Make sure that you add `use(stateResponse())` before adding this plugin.'
+    );
+  }
+};

package/src/serialize.ts

@@ -0,0 +1,125 @@
+// JSON.stringify() doesn't support circular dependencies or keeping
+// falsy values.  This does.
+//
+// Mostly adapted from https://github.com/isaacs/json-stringify-safe
+
+// replacement tokens
+const UNDEFINED = '~~~ undefined ~~~';
+const NULL = `~~~ null ~~~`;
+const FALSE = `~~~ false ~~~`;
+const ZERO = `~~~ zero ~~~`;
+const EMPTY_STRING = `~~~ empty string ~~~`;
+const CIRCULAR = '~~~ Circular Reference ~~~';
+const ANONYMOUS = '~~~ anonymous function ~~~';
+const INFINITY = '~~~ Infinity ~~~';
+const NEGATIVE_INFINITY = '~~~ -Infinity ~~~';
+// const NAN = '~~~ NaN ~~~'
+
+/**
+ * Fix BigInt serialization
+ * BigInts are not supported by JSON.stringify in Hermes android.
+ * This is a workaround.
+ * https://github.com/GoogleChromeLabs/jsbi/issues/30#issuecomment-953187833
+ * https://github.com/infinitered/reactotron/issues/1436
+ */
+declare global {
+  interface BigInt {
+    toJSON(): string;
+  }
+}
+if (typeof BigInt !== 'undefined') {
+  // eslint-disable-next-line no-extend-native
+  BigInt.prototype.toJSON = function () {
+    return this.toString();
+  };
+}
+
+/**
+ * Attempts to give a name to a function.
+ *
+ * @param {Function} fn - The function to name.
+ */
+function getFunctionName(fn: any): string {
+  const n = fn.name;
+  if (n === null || n === undefined || n === '') {
+    return ANONYMOUS;
+  } else {
+    return `~~~ ${n}() ~~~`;
+  }
+}
+
+/**
+ * Serializes an object to JSON.
+ *
+ *  @param {any} source - The victim.
+ */
+function serialize(source: any, proxyHack = false) {
+  const stack = [] as any[];
+  const keys = [] as string[];
+
+  /**
+   * Replace this object node with something potentially custom.
+   *
+   * @param {*} key - The key currently visited.
+   * @param {*} value - The value to replace.
+   */
+  function serializer(replacer: Function | null) {
+    return function (this: any, key: string, value: any) {
+      // slam dunks
+      if (value === true) return true;
+
+      // weird stuff
+      // if (Object.is(value, NaN)) return NAN // OK, apparently this is hard... leaving out for now
+      if (value === Infinity) return INFINITY;
+      if (value === -Infinity) return NEGATIVE_INFINITY;
+      if (value === 0) return ZERO;
+
+      // classic javascript
+      if (value === undefined) return UNDEFINED;
+      if (value === null) return NULL;
+      if (value === false) return FALSE;
+
+      // head shakers
+      if (value === -0) return ZERO; // eslint-disable-line
+      if (value === '') return EMPTY_STRING;
+
+      if (proxyHack && typeof value === 'object' && value.nativeEvent) {
+        return value.nativeEvent;
+      }
+
+      // known types that have easy resolving
+      switch (typeof value) {
+        case 'string':
+          return value;
+        case 'number':
+          return value;
+        case 'bigint':
+          return value.toString();
+        case 'function':
+          return getFunctionName(value);
+      }
+
+      // Tough things to crack
+      // If we have an iterator but are not an array (because arrays are easily seralizeable already)...
+      if (value[Symbol.iterator] && !Array.isArray(value)) {
+        // Convert to an array!
+        return [...value];
+      }
+
+      if (stack.length > 0) {
+        // check for prior existance
+        const thisPos = stack.indexOf(this);
+        ~thisPos ? stack.splice(thisPos + 1) : stack.push(this);
+        ~thisPos ? keys.splice(thisPos, Infinity, key) : keys.push(key);
+        if (~stack.indexOf(value)) value = CIRCULAR;
+      } else {
+        stack.push(value);
+      }
+
+      return replacer == null ? value : replacer.call(this, key, value);
+    };
+  }
+  return JSON.stringify(source, serializer(null));
+}
+
+export default serialize;

package/src/stopwatch.ts

@@ -0,0 +1,50 @@
+/// <reference types="node" />
+
+declare const global: any;
+
+const hasHirezNodeTimer =
+  false &&
+  typeof process === 'object' &&
+  process &&
+  process.hrtime &&
+  typeof process.hrtime === 'function';
+
+// the default timer
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const defaultPerformanceNow = (started?: number) => Date.now();
+
+// try to find the browser-based performance timer
+const nativePerformance =
+  typeof window !== 'undefined' &&
+  window &&
+  (window.performance ||
+    (window as any).msPerformance ||
+    (window as any).webkitPerformance);
+
+// the function we're trying to assign
+let performanceNow = defaultPerformanceNow;
+
+// accepts an already started time and returns the number of milliseconds
+let delta = (started: number) => performanceNow() - started;
+
+if (hasHirezNodeTimer) {
+  performanceNow = process.hrtime as any;
+  // delta = (started) => performanceNow(started)[1] / 1000000;
+  delta = (started) => performanceNow(started) / 1000000;
+} else if (global.nativePerformanceNow) {
+  // react native 47
+  performanceNow = global.nativePerformanceNow;
+} else if (nativePerformance) {
+  // browsers + safely check for react native < 47
+  performanceNow = () => nativePerformance.now && nativePerformance.now();
+}
+
+/**
+ * Starts a lame, low-res timer.  Returns a function which when invoked,
+ * gives you the number of milliseconds since passing.  ish.
+ */
+export const start = () => {
+  //  record the start time
+  const started = performanceNow();
+  return () => delta(started);
+};

package/src/validate.ts

@@ -0,0 +1,38 @@
+import type { ClientOptions } from './client-options';
+import type { DReactionCore } from './';
+
+const isCreateSocketValid = (
+  createSocket: unknown
+): createSocket is ClientOptions<DReactionCore>['createSocket'] =>
+  typeof createSocket !== 'undefined' && createSocket !== null;
+const isHostValid = (host: string): boolean =>
+  (typeof host === 'string' && host && host !== '') as boolean;
+const isPortValid = (port: number): boolean =>
+  typeof port === 'number' && port >= 1 && port <= 65535;
+const onCommandValid = (fn: (cmd: string) => any) => typeof fn === 'function';
+
+/**
+ * Ensures the options are sane to run this baby.  Throw if not.  These
+ * are basically sanity checks.
+ */
+const validate = (options: ClientOptions<DReactionCore>) => {
+  const { createSocket, host, port, onCommand } = options;
+
+  if (!isCreateSocketValid(createSocket)) {
+    throw new Error('invalid createSocket function');
+  }
+
+  if (!isHostValid(host!)) {
+    throw new Error('invalid host');
+  }
+
+  if (!isPortValid(port!)) {
+    throw new Error('invalid port');
+  }
+
+  if (!onCommandValid(onCommand!)) {
+    throw new Error('invalid onCommand handler');
+  }
+};
+
+export default validate;