@aiwayds/dsh-opentui 0.1.0 → 0.2.0

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/cross/index.ts

@@ -0,0 +1,190 @@
+import type { AsyncParserContextOptions } from '../context/async-parser';
+import {
+  createAsyncParserContext,
+  parseTopAsync,
+} from '../context/async-parser';
+import type { CrossDeserializerContextOptions } from '../context/deserializer';
+import {
+  createCrossDeserializerContext,
+  deserializeTop,
+} from '../context/deserializer';
+import type { CrossContextOptions } from '../context/serializer';
+import {
+  createCrossSerializerContext,
+  serializeTopCross,
+} from '../context/serializer';
+import type {
+  StreamParserContextOptions,
+  SyncParserContextOptions,
+} from '../context/sync-parser';
+import {
+  createStreamParserContext,
+  createSyncParserContext,
+  destroyStreamParse,
+  parseTop,
+  startStreamParse,
+} from '../context/sync-parser';
+import { resolvePlugins, SerovalMode } from '../plugin';
+import type { SerovalNode } from '../types';
+
+export interface CrossSerializeOptions
+  extends SyncParserContextOptions,
+    CrossContextOptions {}
+
+export function crossSerialize<T>(
+  source: T,
+  options: CrossSerializeOptions = {},
+): string {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createSyncParserContext(SerovalMode.Cross, {
+    plugins,
+    disabledFeatures: options.disabledFeatures,
+    refs: options.refs,
+  });
+  const tree = parseTop(ctx, source);
+  const serial = createCrossSerializerContext({
+    plugins,
+    features: ctx.base.features,
+    scopeId: options.scopeId,
+    markedRefs: ctx.base.marked,
+  });
+  return serializeTopCross(serial, tree);
+}
+
+export interface CrossSerializeAsyncOptions
+  extends AsyncParserContextOptions,
+    CrossContextOptions {}
+
+export async function crossSerializeAsync<T>(
+  source: T,
+  options: CrossSerializeAsyncOptions = {},
+): Promise<string> {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createAsyncParserContext(SerovalMode.Cross, {
+    plugins,
+    disabledFeatures: options.disabledFeatures,
+    refs: options.refs,
+  });
+  const tree = await parseTopAsync(ctx, source);
+  const serial = createCrossSerializerContext({
+    plugins,
+    features: ctx.base.features,
+    scopeId: options.scopeId,
+    markedRefs: ctx.base.marked,
+  });
+  return serializeTopCross(serial, tree);
+}
+
+export type ToCrossJSONOptions = SyncParserContextOptions;
+
+export function toCrossJSON<T>(
+  source: T,
+  options: ToCrossJSONOptions = {},
+): SerovalNode {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createSyncParserContext(SerovalMode.Cross, {
+    plugins,
+    disabledFeatures: options.disabledFeatures,
+    refs: options.refs,
+  });
+  return parseTop(ctx, source);
+}
+
+export type ToCrossJSONAsyncOptions = AsyncParserContextOptions;
+
+export async function toCrossJSONAsync<T>(
+  source: T,
+  options: ToCrossJSONAsyncOptions = {},
+): Promise<SerovalNode> {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createAsyncParserContext(SerovalMode.Cross, {
+    plugins,
+    disabledFeatures: options.disabledFeatures,
+    refs: options.refs,
+  });
+  return await parseTopAsync(ctx, source);
+}
+
+export interface CrossSerializeStreamOptions
+  extends Omit<StreamParserContextOptions, 'onParse'>,
+    CrossContextOptions {
+  onSerialize: (data: string, initial: boolean) => void;
+}
+
+export function crossSerializeStream<T>(
+  source: T,
+  options: CrossSerializeStreamOptions,
+): () => void {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createStreamParserContext({
+    plugins,
+    refs: options.refs,
+    disabledFeatures: options.disabledFeatures,
+    onParse(node, initial): void {
+      const serial = createCrossSerializerContext({
+        plugins,
+        features: ctx.base.features,
+        scopeId: options.scopeId,
+        markedRefs: ctx.base.marked,
+      });
+
+      let serialized: string;
+
+      try {
+        serialized = serializeTopCross(serial, node);
+      } catch (err) {
+        if (options.onError) {
+          options.onError(err);
+        }
+        return;
+      }
+
+      options.onSerialize(serialized, initial);
+    },
+    onError: options.onError,
+    onDone: options.onDone,
+  });
+
+  startStreamParse(ctx, source);
+
+  return destroyStreamParse.bind(null, ctx);
+}
+
+export type ToCrossJSONStreamOptions = StreamParserContextOptions;
+
+export function toCrossJSONStream<T>(
+  source: T,
+  options: ToCrossJSONStreamOptions,
+): () => void {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createStreamParserContext({
+    plugins,
+    refs: options.refs,
+    disabledFeatures: options.disabledFeatures,
+    depthLimit: options.depthLimit,
+    onParse: options.onParse,
+    onError: options.onError,
+    onDone: options.onDone,
+  });
+
+  startStreamParse(ctx, source);
+
+  return destroyStreamParse.bind(null, ctx);
+}
+
+export type FromCrossJSONOptions = CrossDeserializerContextOptions;
+
+export function fromCrossJSON<T>(
+  source: SerovalNode,
+  options: FromCrossJSONOptions,
+): T {
+  const plugins = resolvePlugins(options.plugins);
+  const ctx = createCrossDeserializerContext({
+    plugins,
+    refs: options.refs,
+    features: options.features,
+    disabledFeatures: options.disabledFeatures,
+    depthLimit: options.depthLimit,
+  });
+  return deserializeTop(ctx, source) as T;
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/errors.ts

@@ -0,0 +1,196 @@
+/// <reference types="pridepack/env" />
+
+import { serializeString } from './string';
+import type { SerovalNode } from './types';
+
+const { toString: objectToString } = /* @__PURE__ */ Object.prototype;
+
+const enum StepErrorCodes {
+  Parse = 1,
+  Serialize = 2,
+  Deserialize = 3,
+}
+
+function getErrorMessageDev(type: string, cause: unknown): string {
+  if (cause instanceof Error) {
+    return `Seroval caught an error during the ${type} process.
+
+${cause.name}
+${cause.message}
+
+- For more information, please check the "cause" property of this error.
+- If you believe this is an error in Seroval, please submit an issue at https://github.com/lxsmnsyc/seroval/issues/new`;
+  }
+  return `Seroval caught an error during the ${type} process.
+
+"${objectToString.call(cause)}"
+
+For more information, please check the "cause" property of this error.`;
+}
+
+const STEP_ERROR_CODES: Record<string, StepErrorCodes> = {
+  parsing: StepErrorCodes.Parse,
+  serialization: StepErrorCodes.Serialize,
+  deserialization: StepErrorCodes.Deserialize,
+};
+
+function getErrorMessageProd(type: string): string {
+  return `Seroval Error (step: ${STEP_ERROR_CODES[type]})`;
+}
+
+const getErrorMessage = (type: string, cause: any) =>
+  import.meta.env.PROD
+    ? getErrorMessageProd(type)
+    : getErrorMessageDev(type, cause);
+
+export class SerovalError extends Error {
+  constructor(
+    type: string,
+    public cause: unknown,
+  ) {
+    super(getErrorMessage(type, cause));
+  }
+}
+
+export class SerovalParserError extends SerovalError {
+  constructor(cause: unknown) {
+    super('parsing', cause);
+  }
+}
+
+export class SerovalSerializationError extends SerovalError {
+  constructor(cause: unknown) {
+    super('serialization', cause);
+  }
+}
+
+export class SerovalDeserializationError extends SerovalError {
+  constructor(cause: unknown) {
+    super('deserialization', cause);
+  }
+}
+
+const enum SpecificErrorCodes {
+  UnsupportedType = 1,
+  UnsupportedNode = 2,
+  MissingPlugin = 3,
+  MissingInstance = 4,
+  MissingReference = 5,
+  MissingReferenceForId = 6,
+  UnknownTypedArray = 7,
+  MalformedNode = 8,
+  ConflictedNodeId = 9,
+  DepthLimit = 10,
+}
+
+function getSpecificErrorMessage(code: SpecificErrorCodes): string {
+  return `Seroval Error (specific: ${code})`;
+}
+
+export class SerovalUnsupportedTypeError extends Error {
+  constructor(public value: unknown) {
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.UnsupportedType)
+        : `The value ${objectToString.call(value)} of type "${typeof value}" cannot be parsed/serialized.
+      
+There are few workarounds for this problem:
+- Transform the value in a way that it can be serialized.
+- If the reference is present on multiple runtimes (isomorphic), you can use the Reference API to map the references.`,
+    );
+  }
+}
+
+export class SerovalUnsupportedNodeError extends Error {
+  constructor(node: SerovalNode) {
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.UnsupportedNode)
+        : 'Unsupported node type "' + node.t + '".',
+    );
+  }
+}
+
+export class SerovalMissingPluginError extends Error {
+  constructor(tag: string) {
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.MissingPlugin)
+        : 'Missing plugin for tag "' + tag + '".',
+    );
+  }
+}
+
+export class SerovalMissingInstanceError extends Error {
+  constructor(tag: string) {
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.MissingInstance)
+        : 'Missing "' + tag + '" instance.',
+    );
+  }
+}
+
+export class SerovalMissingReferenceError extends Error {
+  constructor(public value: unknown) {
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.MissingReference)
+        : 'Missing reference for the value "' +
+            objectToString.call(value) +
+            '" of type "' +
+            typeof value +
+            '"',
+    );
+  }
+}
+
+export class SerovalMissingReferenceForIdError extends Error {
+  constructor(id: string) {
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.MissingReferenceForId)
+        : 'Missing reference for id "' + serializeString(id) + '"',
+    );
+  }
+}
+
+export class SerovalUnknownTypedArrayError extends Error {
+  constructor(name: string) {
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.UnknownTypedArray)
+        : 'Unknown TypedArray "' + name + '"',
+    );
+  }
+}
+
+export class SerovalMalformedNodeError extends Error {
+  constructor(node: SerovalNode) {
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.MalformedNode)
+        : 'Malformed node type "' + node.t + '".',
+    );
+  }
+}
+
+export class SerovalConflictedNodeIdError extends Error {
+  constructor(node: SerovalNode) {
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.ConflictedNodeId)
+        : 'Conflicted node id "' + node.i + '".',
+    );
+  }
+}
+
+export class SerovalDepthLimitError extends Error {
+  constructor(limit: number) {
+    super(
+      import.meta.env.PROD
+        ? getSpecificErrorMessage(SpecificErrorCodes.ConflictedNodeId)
+        : 'Depth limit of ' + limit + ' reached',
+    );
+  }
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/function-string.ts

@@ -0,0 +1,31 @@
+declare const T: unknown;
+
+const RETURN = () => T;
+const SERIALIZED_RETURN = /* @__PURE__ */ RETURN.toString();
+
+const IS_MODERN = /* @__PURE__ */ /=>/.test(SERIALIZED_RETURN);
+
+export function createFunction(parameters: string[], body: string): string {
+  if (IS_MODERN) {
+    const joined =
+      parameters.length === 1
+        ? parameters[0]
+        : '(' + parameters.join(',') + ')';
+    return joined + '=>' + (body.startsWith('{') ? '(' + body + ')' : body);
+  }
+  return 'function(' + parameters.join(',') + '){return ' + body + '}';
+}
+
+export function createEffectfulFunction(
+  parameters: string[],
+  body: string,
+): string {
+  if (IS_MODERN) {
+    const joined =
+      parameters.length === 1
+        ? parameters[0]
+        : '(' + parameters.join(',') + ')';
+    return joined + '=>{' + body + '}';
+  }
+  return 'function(' + parameters.join(',') + '){' + body + '}';
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/keys.ts

@@ -0,0 +1,17 @@
+import { serializeString } from './string';
+
+// Used for mapping isomorphic references
+export const REFERENCES_KEY = '__SEROVAL_REFS__';
+
+export const GLOBAL_CONTEXT_REFERENCES = '$R';
+
+const GLOBAL_CONTEXT_R = `self.${GLOBAL_CONTEXT_REFERENCES}`;
+
+export function getCrossReferenceHeader(id?: string): string {
+  if (id == null) {
+    return `${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||[]`;
+  }
+  return `(${GLOBAL_CONTEXT_R}=${GLOBAL_CONTEXT_R}||{})["${serializeString(
+    id,
+  )}"]=[]`;
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/literals.ts

@@ -0,0 +1,43 @@
+import { NIL, SerovalConstant, SerovalNodeType } from './constants';
+import { createSerovalNode } from './node';
+import type { SerovalConstantNode } from './types';
+
+function createConstantNode(value: SerovalConstant): SerovalConstantNode {
+  return createSerovalNode(
+    SerovalNodeType.Constant,
+    NIL,
+    value,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+    NIL,
+  );
+}
+
+export const TRUE_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.True,
+);
+export const FALSE_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.False,
+);
+export const UNDEFINED_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.Undefined,
+);
+export const NULL_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.Null,
+);
+export const NEG_ZERO_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.NegZero,
+);
+export const INFINITY_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.Inf,
+);
+export const NEG_INFINITY_NODE = /* @__PURE__ */ createConstantNode(
+  SerovalConstant.NegInf,
+);
+export const NAN_NODE = /* @__PURE__ */ createConstantNode(SerovalConstant.Nan);

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/node.ts

@@ -0,0 +1,40 @@
+import type { SerovalNodeType } from './constants';
+import type { SerovalNode } from './types';
+
+type ExtractedNodeType<T extends SerovalNodeType> = Extract<
+  SerovalNode,
+  { t: T }
+>;
+
+export function createSerovalNode<
+  T extends SerovalNodeType,
+  N extends ExtractedNodeType<T>,
+>(
+  t: T,
+  i: N['i'],
+  s: N['s'],
+  c: N['c'],
+  m: N['m'],
+  p: N['p'],
+  e: N['e'],
+  a: N['a'],
+  f: N['f'],
+  b: N['b'],
+  o: N['o'],
+  l: N['l'],
+): N {
+  return {
+    t,
+    i,
+    s,
+    c,
+    m,
+    p,
+    e,
+    a,
+    f,
+    b,
+    o,
+    l,
+  } as N;
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/opaque-reference.ts

@@ -0,0 +1,9 @@
+/**
+ * An opaque reference allows hiding values from the serializer.
+ */
+export class OpaqueReference<V, R = undefined> {
+  constructor(
+    public readonly value: V,
+    public readonly replacement?: R,
+  ) {}
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/plugin.ts

@@ -0,0 +1,105 @@
+import type { AsyncParsePluginContext } from './context/async-parser';
+import type { DeserializePluginContext } from './context/deserializer';
+import type { SerializePluginContext } from './context/serializer';
+import type {
+  StreamParsePluginContext,
+  SyncParsePluginContext,
+} from './context/sync-parser';
+import type { SerovalNode } from './types';
+
+export const enum SerovalMode {
+  Vanilla = 1,
+  Cross = 2,
+}
+
+export interface PluginData {
+  id: number;
+}
+
+export type PluginInfo = {
+  [key: string]: SerovalNode;
+};
+
+export interface Plugin<Value, Info extends PluginInfo> {
+  /**
+   * A unique string that helps idenfity the plugin
+   */
+  tag: string;
+  /**
+   * List of dependency plugins
+   */
+  extends?: Plugin<any, any>[];
+  /**
+   * Method to test if a value is an expected value of the plugin
+   * @param value
+   */
+  test(value: unknown): boolean;
+  /**
+   * Parsing modes
+   */
+  parse: {
+    sync?: (
+      value: Value,
+      ctx: SyncParsePluginContext,
+      data: PluginData,
+    ) => Info;
+    async?: (
+      value: Value,
+      ctx: AsyncParsePluginContext,
+      data: PluginData,
+    ) => Promise<Info>;
+    stream?: (
+      value: Value,
+      ctx: StreamParsePluginContext,
+      data: PluginData,
+    ) => Info;
+  };
+  /**
+   * Convert the parsed node into a JS string
+   */
+  serialize(node: Info, ctx: SerializePluginContext, data: PluginData): string;
+  /**
+   * Convert the parsed node into its runtime equivalent.
+   */
+  deserialize(
+    node: Info,
+    ctx: DeserializePluginContext,
+    data: PluginData,
+  ): Value;
+}
+
+export function createPlugin<Value, Info extends PluginInfo>(
+  plugin: Plugin<Value, Info>,
+): Plugin<Value, Info> {
+  return plugin;
+}
+
+export interface PluginAccessOptions {
+  plugins?: Plugin<any, any>[];
+}
+
+function dedupePlugins(
+  deduped: Set<Plugin<any, any>>,
+  plugins: Plugin<any, any>[],
+): void {
+  for (let i = 0, len = plugins.length; i < len; i++) {
+    const current = plugins[i];
+    if (!deduped.has(current)) {
+      deduped.add(current);
+      if (current.extends) {
+        dedupePlugins(deduped, current.extends);
+      }
+    }
+  }
+}
+
+export function resolvePlugins(
+  plugins?: Plugin<any, any>[],
+): Plugin<any, any>[] | undefined {
+  if (plugins) {
+    const deduped = new Set<Plugin<any, any>>();
+    dedupePlugins(deduped, plugins);
+    return [...deduped];
+  }
+  return undefined;
+}

package/dist-host/node_modules/.pnpm/seroval@1.5.6/node_modules/seroval/src/core/reference.ts

@@ -0,0 +1,66 @@
+import {
+  SerovalMissingReferenceError,
+  SerovalMissingReferenceForIdError,
+} from '..';
+import { REFERENCES_KEY } from './keys';
+
+const REFERENCE = new Map<unknown, string>();
+const INV_REFERENCE = new Map<string, unknown>();
+
+export function createReference<T>(id: string, value: T): T {
+  REFERENCE.set(value, id);
+  INV_REFERENCE.set(id, value);
+  return value;
+}
+
+export function hasReferenceID<T>(value: T): boolean {
+  return REFERENCE.has(value);
+}
+
+export function hasReference(id: string): boolean {
+  return INV_REFERENCE.has(id);
+}
+
+export function getReferenceID<T>(value: T): string {
+  if (hasReferenceID(value)) {
+    return REFERENCE.get(value)!;
+  }
+  throw new SerovalMissingReferenceError(value);
+}
+
+export function getReference<T>(id: string): T {
+  if (hasReference(id)) {
+    return INV_REFERENCE.get(id) as T;
+  }
+  throw new SerovalMissingReferenceForIdError(id);
+}
+
+if (typeof globalThis !== 'undefined') {
+  Object.defineProperty(globalThis, REFERENCES_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false,
+  });
+} else if (typeof window !== 'undefined') {
+  Object.defineProperty(window, REFERENCES_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false,
+  });
+} else if (typeof self !== 'undefined') {
+  Object.defineProperty(self, REFERENCES_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false,
+  });
+} else if (typeof global !== 'undefined') {
+  Object.defineProperty(global, REFERENCES_KEY, {
+    value: INV_REFERENCE,
+    configurable: true,
+    writable: false,
+    enumerable: false,
+  });
+}