@voiceflow/sdk-runtime 1.2.1

package/build/esm/trace/trace.component.js

@@ -0,0 +1,9 @@
+export const createTraceComponent = (type) => (handle) => {
+    if (typeof handle === 'function') {
+        return {
+            canHandle: (trace) => trace.type === type,
+            handle,
+        };
+    }
+    return handle;
+};

package/build/esm/trace/trace.interface.d.ts

@@ -0,0 +1,16 @@
+import type { RuntimeInteractRequest, RuntimeState, RuntimeTrace } from '../runtime/runtime.interface.js';
+export interface TraceOptions<T> {
+    traces?: TraceDeclaration<T, any>[];
+}
+export interface TraceDeclaration<Context, Trace extends RuntimeTrace> {
+    canHandle: TraceCanHandle<Trace>;
+    handle: TraceAccumulator<Context, Trace>;
+}
+export declare type TraceCanHandle<Trace extends RuntimeTrace> = (trace: Trace) => boolean;
+export interface TraceHandlerMeta<Context> {
+    request: RuntimeInteractRequest;
+    state: RuntimeState;
+    context: Context;
+}
+export declare type TraceAccumulator<Context, Trace extends RuntimeTrace> = (meta: TraceHandlerMeta<Context>, trace: Trace) => Context;
+//# sourceMappingURL=trace.interface.d.ts.map

package/build/esm/trace/trace.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.interface.d.ts","sourceRoot":"","sources":["../../../src/trace/trace.interface.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEtG,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,MAAM,CAAC,EAAE,gBAAgB,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;CACrC;AAED,MAAM,WAAW,gBAAgB,CAAC,OAAO,EAAE,KAAK,SAAS,YAAY;IACnE,SAAS,EAAE,cAAc,CAAC,KAAK,CAAC,CAAC;IACjC,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;CAC1C;AAED,oBAAY,cAAc,CAAC,KAAK,SAAS,YAAY,IAAI,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC;AAEnF,MAAM,WAAW,gBAAgB,CAAC,OAAO;IACvC,OAAO,EAAE,sBAAsB,CAAC;IAChC,KAAK,EAAE,YAAY,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,oBAAY,gBAAgB,CAAC,OAAO,EAAE,KAAK,SAAS,YAAY,IAAI,CAClE,IAAI,EAAE,gBAAgB,CAAC,OAAO,CAAC,EAC/B,KAAK,EAAE,KAAK,KACT,OAAO,CAAC"}

package/build/esm/trace/trace.interface.js

@@ -0,0 +1 @@
+export {};

package/build/esm/trace/trace.service.d.ts

@@ -0,0 +1,10 @@
+import type { RuntimeInteractRequest, RuntimeInteractResponse } from '../runtime/runtime.interface.js';
+import type { TraceDeclaration, TraceOptions } from './trace.interface.js';
+export declare class TraceService<T = unknown> {
+    private readonly traces;
+    constructor(options?: TraceOptions<T>);
+    registerTrace(step: TraceDeclaration<T, any>): this;
+    registerTraces(steps: TraceDeclaration<T, any>[]): this;
+    processTrace(context: T, request: RuntimeInteractRequest, response: RuntimeInteractResponse): Promise<T>;
+}
+//# sourceMappingURL=trace.service.d.ts.map

package/build/esm/trace/trace.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace.service.d.ts","sourceRoot":"","sources":["../../../src/trace/trace.service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAEtG,OAAO,KAAK,EAAE,gBAAgB,EAAoB,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAE1F,qBAAa,YAAY,CAAC,CAAC,GAAG,OAAO;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkC;gBAEtC,OAAO,GAAE,YAAY,CAAC,CAAC,CAAM;IAIzC,aAAa,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,IAAI;IAKnD,cAAc,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,IAAI;IAKjD,YAAY,CACvB,OAAO,EAAE,CAAC,EACV,OAAO,EAAE,sBAAsB,EAC/B,QAAQ,EAAE,uBAAuB,GAChC,OAAO,CAAC,CAAC,CAAC;CAgBd"}

package/build/esm/trace/trace.service.js

@@ -0,0 +1,29 @@
+export class TraceService {
+    constructor(options = {}) {
+        this.traces = [];
+        this.registerTraces(options.traces ?? []);
+    }
+    registerTrace(step) {
+        this.traces.push(step);
+        return this;
+    }
+    registerTraces(steps) {
+        steps.forEach((step) => this.registerTrace(step));
+        return this;
+    }
+    async processTrace(context, request, response) {
+        const meta = {
+            request,
+            state: response.state,
+            context,
+        };
+        for (const trace of response.trace) {
+            const step = this.traces.find((step) => step.canHandle(trace));
+            if (step) {
+                // eslint-disable-next-line no-await-in-loop
+                meta.context = await step.handle(meta, trace);
+            }
+        }
+        return meta.context;
+    }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@voiceflow/sdk-runtime",
+  "version": "1.2.1",
+  "exports": {
+    ".": {
+      "import": "./build/esm/main.js",
+      "default": "./build/cjs/main.js"
+    }
+  },
+  "main": "build/cjs/main.js",
+  "types": "build/esm/main.d.ts",
+  "scripts": {
+    "build": "yarn g:run-p build:cjs build:esm",
+    "prebuild:cjs": "yarn g:rimraf build/cjs",
+    "build:cjs": "yarn prebuild:cjs && yarn g:tsc -p tsconfig.build.cjs.json && yarn g:tsc-alias -p tsconfig.build.cjs.json && yarn postbuild:cjs",
+    "postbuild:cjs": "touch build/cjs/package.json && echo '{ \"type\": \"commonjs\" }' > build/cjs/package.json",
+    "prebuild:esm": "yarn g:rimraf build/esm",
+    "build:esm": "yarn prebuild:esm && yarn g:tsc -p tsconfig.build.esm.json && yarn g:tsc-alias -p tsconfig.build.esm.json && yarn postbuild:esm",
+    "postbuild:esm": "touch build/esm/package.json && echo '{ \"type\": \"module\" }' > build/esm/package.json",
+    "lint": "yarn g:run-p lint:eslint \"lint:prettier --check\"",
+    "lint:eslint": "yarn g:eslint \"src/**/*.{js,ts}\"",
+    "lint:fix": "yarn g:run-p \"lint:eslint --fix\" \"lint:prettier --write\"",
+    "lint:prettier": "yarn g:prettier . \"!**/*.{js,ts}\"",
+    "lint:report": "yarn g:eslint-output --quiet './src/**/*.{js,ts}'",
+    "test:dependencies": "depcheck",
+    "test:unit": "yarn g:jest --passWithNoTests"
+  },
+  "prettier": "@voiceflow-meta/prettier-config",
+  "eslintConfig": {
+    "extends": "@voiceflow-meta/eslint-config"
+  },
+  "dependencies": {
+    "http-errors": "^2.0.0"
+  },
+  "devDependencies": {
+    "@types/http-errors": "^1.8.2",
+    "@voiceflow-meta/eslint-config": "1.1.2",
+    "@voiceflow-meta/prettier-config": "1.1.2",
+    "@voiceflow-meta/typescript-config": "1.1.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "49214dc837eab6ba59490a425d25d818114be2e6"
+}

package/sonar-project.properties

@@ -0,0 +1,6 @@
+sonar.projectName=adapters-sdk-runtime
+sonar.sources=src
+sonar.eslint.reportPaths=sonar/report.json
+sonar.typescript.tsconfigPath=./tsconfig.json
+sonar.coverage.exclusions=**/**
+#sonar.javascript.lcov.reportPaths=nyc_coverage_unit/lcov.info

package/src/main.ts

@@ -0,0 +1,3 @@
+export * from './runtime/index.js';
+export * from './sdk/index.js';
+export * from './trace/index.js';

package/src/runtime/index.ts

@@ -0,0 +1,2 @@
+export * from './runtime.interface.js';
+export * from './runtime.service.js';

package/src/runtime/runtime.interface.ts

@@ -0,0 +1,177 @@
+// Super broad type so that differing fetch types (ex. builtin, node-fetch, etc.) don't conflict with it
+type FetchFn = (...parameters: any[]) => Promise<any>;
+
+export interface RuntimeOptions {
+  url: string;
+  authorization: string;
+
+  /**
+   * A ponyfill to use for `fetch()`.
+   * Defaults to the global `fetch()`.
+   */
+  fetchPonyfill?: FetchFn;
+}
+
+export interface RuntimeInteractRequest {
+  action: RuntimeAction;
+  sessionID: string;
+  versionID?: string;
+  config?: any;
+}
+
+export interface RuntimeInteractResponse {
+  state: RuntimeState;
+  request: RuntimeAction;
+  trace: RuntimeTrace[];
+}
+
+export const RuntimeActionTypeSet = new Set(['launch', 'intent', 'text', '...etc'] as const);
+
+export type RuntimeActionType = typeof RuntimeActionTypeSet extends Set<infer K> ? K : never;
+
+export const isRuntimeActionType = (value: unknown): value is RuntimeActionType =>
+  typeof value === 'string' && RuntimeActionTypeSet.has(value as any);
+
+export interface RuntimeAction<T extends RuntimeActionType = RuntimeActionType, P = unknown> {
+  type: T;
+  payload: P;
+}
+
+export const isRuntimeAction = (value: unknown): value is RuntimeAction =>
+  typeof value === 'object' &&
+  Object.prototype.hasOwnProperty.call(value, 'type') &&
+  isRuntimeActionType((value as any).type);
+
+export interface IntentActionPayload {
+  query: string;
+  intent: { name: string };
+  entities: { name: string; value: string }[];
+  confidence?: number;
+}
+
+export type IntentAction = RuntimeAction<'intent', IntentActionPayload>;
+
+export const isIntentAction = (value: unknown): value is IntentAction =>
+  isRuntimeAction(value) && value.type === 'intent';
+
+export const createIntentAction = (payload: IntentActionPayload): IntentAction => ({
+  type: 'intent',
+  payload,
+});
+
+export interface RuntimeState {
+  storage: Record<string, any>;
+  variables: Record<string, any>;
+}
+
+export const RuntimeTraceTypeSet = new Set([
+  'speak',
+  'text',
+  'choice',
+  'card',
+  'visual',
+  'audio',
+  'payload',
+  'stream',
+  'end',
+] as const);
+
+export type RuntimeTraceType = typeof RuntimeTraceTypeSet extends Set<infer K> ? K : never;
+
+export const isRuntimeTraceType = (value: unknown): value is RuntimeTraceType =>
+  typeof value === 'string' && RuntimeTraceTypeSet.has(value as any);
+
+export interface RuntimeTrace<T extends RuntimeTraceType = RuntimeTraceType, P = unknown> {
+  type: T;
+  payload: P;
+}
+
+export const isRuntimeTrace = (value: unknown): value is RuntimeTrace =>
+  typeof value === 'object' &&
+  Object.prototype.hasOwnProperty.call(value, 'type') &&
+  isRuntimeTraceType((value as any).type);
+
+export interface CardTracePayload {
+  card: {
+    type: string;
+    title: string;
+    text: string;
+    image?: {
+      largeImageUrl: string;
+      alt: string;
+    };
+  };
+}
+
+export type CardTrace = RuntimeTrace<'card', CardTracePayload>;
+
+export const isCardTrace = (value: unknown): value is CardTrace => isRuntimeTrace(value) && value.type === 'card';
+
+export type ChoiceTrace = RuntimeTrace<'choice', ChoiceTracePayload>;
+
+export interface ChoiceTracePayload {
+  buttons: { name: string }[];
+}
+
+export const isChoiceTrace = (value: unknown): value is ChoiceTrace => isRuntimeTrace(value) && value.type === 'choice';
+
+export interface PayloadTracePayload {
+  data: any;
+}
+
+export type EndTrace = RuntimeTrace<'end'>;
+
+export const isEndTrace = (value: unknown): value is EndTrace => isRuntimeTrace(value) && value.type === 'end';
+
+export type PayloadTrace = RuntimeTrace<'payload', PayloadTracePayload>;
+
+export const isPayloadTrace = (value: unknown): value is PayloadTrace =>
+  isRuntimeTrace(value) && value.type === 'payload';
+
+export interface SpeakTracePayload {
+  voice?: string;
+  src?: string;
+  message: string;
+  type: 'speak' | 'audio';
+}
+
+export type SpeakTrace = RuntimeTrace<'speak', SpeakTracePayload>;
+
+export const isSpeakTrace = (value: unknown): value is SpeakTrace => isRuntimeTrace(value) && value.type === 'speak';
+
+export interface TextTracePayload {
+  message: string;
+}
+
+export type TextTrace = RuntimeTrace<'text', TextTracePayload>;
+
+export const isTextTrace = (value: unknown): value is TextTrace => isRuntimeTrace(value) && value.type === 'text';
+
+export interface VisualTracePayload {
+  image: string;
+}
+
+export type VisualTrace = RuntimeTrace<'visual', VisualTracePayload>;
+
+export const isVisualTrace = (value: unknown): value is VisualTrace => isRuntimeTrace(value) && value.type === 'visual';
+
+export interface StreamTracePayload {
+  src: string;
+  loop: boolean;
+  description?: string;
+  title?: string;
+  iconImage?: string;
+  backgroundImage?: string;
+  action: string;
+}
+
+export type StreamTrace = RuntimeTrace<'stream', StreamTracePayload>;
+
+export const isStreamTrace = (value: unknown): value is StreamTrace => isRuntimeTrace(value) && value.type === 'stream';
+
+export interface RuntimeHttpRequest {
+  method?: string;
+  params?: URLSearchParams;
+  body?: any;
+  headers?: HeadersInit;
+}

package/src/runtime/runtime.service.ts

@@ -0,0 +1,54 @@
+import createHTTPError from 'http-errors';
+
+import type {
+  RuntimeHttpRequest,
+  RuntimeInteractRequest,
+  RuntimeInteractResponse,
+  RuntimeOptions,
+} from '@/runtime/runtime.interface.js';
+
+export class RuntimeService {
+  private readonly fetch: typeof globalThis.fetch;
+
+  public constructor(private readonly options: RuntimeOptions) {
+    this.fetch = options.fetchPonyfill ?? globalThis.fetch?.bind(globalThis);
+    if (!this.fetch) {
+      throw new TypeError('fetch implementation was not provided and a global fetch was not available');
+    }
+  }
+
+  private async send<T>(path: string, args: RuntimeHttpRequest = {}): Promise<T> {
+    const url = new URL(path, this.options.url);
+    if (args.params) url.search = args.params.toString();
+
+    const result = await this.fetch(url, {
+      method: args.method ?? 'GET',
+      body: args.body ? JSON.stringify(args.body) : undefined,
+      headers: {
+        'content-type': 'application/json',
+        ...(args.headers ?? {}),
+      },
+    });
+
+    const json = (await result.json().catch(() => null)) as any;
+    if (!result.ok) {
+      throw createHTTPError(result.status, result.statusText, json);
+    }
+
+    return json;
+  }
+
+  public async interact(request: RuntimeInteractRequest): Promise<RuntimeInteractResponse> {
+    return this.send<RuntimeInteractResponse>(`state/${request.versionID}/user/${request.sessionID}/interact`, {
+      method: 'POST',
+      body: {
+        action: request.action,
+        config: request.config,
+      },
+      headers: {
+        authorization: this.options.authorization,
+      },
+      params: new URLSearchParams({ verbose: 'true' }),
+    });
+  }
+}

package/src/sdk/index.ts

@@ -0,0 +1,2 @@
+export * from './sdk.interface.js';
+export * from './sdk.service.js';

package/src/sdk/sdk.interface.ts

@@ -0,0 +1,4 @@
+import type { RuntimeOptions } from '@/runtime/runtime.interface.js';
+import type { TraceOptions } from '@/trace/trace.interface.js';
+
+export type VoiceflowRuntimeOptions<T> = RuntimeOptions & TraceOptions<T>;

package/src/sdk/sdk.service.ts

@@ -0,0 +1,35 @@
+import type { IntentActionPayload, RuntimeInteractRequest } from '@/runtime/runtime.interface.js';
+import { createIntentAction } from '@/runtime/runtime.interface.js';
+import { RuntimeService } from '@/runtime/runtime.service.js';
+import type { TraceDeclaration } from '@/trace/trace.interface.js';
+import { TraceService } from '@/trace/trace.service.js';
+
+import type { VoiceflowRuntimeOptions } from './sdk.interface.js';
+
+export class VoiceflowRuntime<T> {
+  private readonly runtime: RuntimeService;
+
+  private readonly trace: TraceService<T>;
+
+  public constructor(options: VoiceflowRuntimeOptions<T>) {
+    this.runtime = new RuntimeService(options);
+    this.trace = new TraceService(options);
+  }
+
+  public registerStep(step: TraceDeclaration<T, any>) {
+    this.trace.registerTrace(step);
+    return this;
+  }
+
+  public async interact(context: T, request: RuntimeInteractRequest): Promise<T> {
+    const response = await this.runtime.interact(request);
+    return this.trace.processTrace(context, request, response);
+  }
+
+  public intent(request: { context: T; sessionID: string; payload: IntentActionPayload }): Promise<T> {
+    return this.interact(request.context, {
+      action: createIntentAction(request.payload),
+      sessionID: request.sessionID,
+    });
+  }
+}

package/src/trace/components/card.component.ts

@@ -0,0 +1,5 @@
+import type { CardTrace } from '@/runtime/runtime.interface.js';
+
+import { createTraceComponent } from '../trace.component.js';
+
+export const CardTraceComponent = createTraceComponent<CardTrace>('card');

package/src/trace/components/choice.component.ts

@@ -0,0 +1,5 @@
+import type { ChoiceTrace } from '@/runtime/runtime.interface.js';
+
+import { createTraceComponent } from '../trace.component.js';
+
+export const ChoiceTraceComponent = createTraceComponent<ChoiceTrace>('choice');

package/src/trace/components/end.component.ts

@@ -0,0 +1,5 @@
+import type { EndTrace } from '@/runtime/runtime.interface.js';
+
+import { createTraceComponent } from '../trace.component.js';
+
+export const EndTraceComponent = createTraceComponent<EndTrace>('end');

package/src/trace/components/index.ts

@@ -0,0 +1,8 @@
+export * from './card.component.js';
+export * from './choice.component.js';
+export * from './end.component.js';
+export * from './payload.component.js';
+export * from './speak.component.js';
+export * from './stream.component.js';
+export * from './text.component.js';
+export * from './visual.component.js';

package/src/trace/components/payload.component.ts

@@ -0,0 +1,5 @@
+import type { PayloadTrace } from '@/runtime/runtime.interface.js';
+
+import { createTraceComponent } from '../trace.component.js';
+
+export const PayloadTraceComponent = createTraceComponent<PayloadTrace>('payload');

package/src/trace/components/speak.component.ts

@@ -0,0 +1,5 @@
+import type { SpeakTrace } from '@/runtime/runtime.interface.js';
+
+import { createTraceComponent } from '../trace.component.js';
+
+export const SpeakTraceComponent = createTraceComponent<SpeakTrace>('speak');

package/src/trace/components/stream.component.ts

@@ -0,0 +1,5 @@
+import type { StreamTrace } from '@/runtime/runtime.interface.js';
+
+import { createTraceComponent } from '../trace.component.js';
+
+export const StreamTraceComponent = createTraceComponent<StreamTrace>('stream');

package/src/trace/components/text.component.ts

@@ -0,0 +1,5 @@
+import type { TextTrace } from '@/runtime/runtime.interface.js';
+
+import { createTraceComponent } from '../trace.component.js';
+
+export const TextTraceComponent = createTraceComponent<TextTrace>('text');

package/src/trace/components/visual.component.ts

@@ -0,0 +1,5 @@
+import type { VisualTrace } from '@/runtime/runtime.interface.js';
+
+import { createTraceComponent } from '../trace.component.js';
+
+export const VisualTraceComponent = createTraceComponent<VisualTrace>('visual');

package/src/trace/index.ts

@@ -0,0 +1,4 @@
+export * from './components/index.js';
+export * from './trace.component.js';
+export * from './trace.interface.js';
+export * from './trace.service.js';

package/src/trace/trace.component.ts

@@ -0,0 +1,23 @@
+import type { RuntimeTrace } from '@/runtime/runtime.interface.js';
+
+import type { TraceAccumulator, TraceDeclaration } from './trace.interface.js';
+
+export interface TraceComponentOverload<Trace extends RuntimeTrace> {
+  <Context>(declaration: TraceDeclaration<Context, Trace>): Required<TraceDeclaration<Context, Trace>>;
+  <Context>(handle: TraceAccumulator<Context, Trace>): Required<TraceDeclaration<Context, Trace>>;
+}
+
+export const createTraceComponent =
+  <Trace extends RuntimeTrace>(type: Trace['type']): TraceComponentOverload<Trace> =>
+  <Context>(
+    handle: TraceDeclaration<Context, Trace> | TraceAccumulator<Context, Trace>
+  ): TraceDeclaration<Context, Trace> => {
+    if (typeof handle === 'function') {
+      return {
+        canHandle: (trace) => trace.type === type,
+        handle,
+      };
+    }
+
+    return handle;
+  };

package/src/trace/trace.interface.ts

@@ -0,0 +1,23 @@
+import type { RuntimeInteractRequest, RuntimeState, RuntimeTrace } from '@/runtime/runtime.interface';
+
+export interface TraceOptions<T> {
+  traces?: TraceDeclaration<T, any>[];
+}
+
+export interface TraceDeclaration<Context, Trace extends RuntimeTrace> {
+  canHandle: TraceCanHandle<Trace>;
+  handle: TraceAccumulator<Context, Trace>;
+}
+
+export type TraceCanHandle<Trace extends RuntimeTrace> = (trace: Trace) => boolean;
+
+export interface TraceHandlerMeta<Context> {
+  request: RuntimeInteractRequest;
+  state: RuntimeState;
+  context: Context;
+}
+
+export type TraceAccumulator<Context, Trace extends RuntimeTrace> = (
+  meta: TraceHandlerMeta<Context>,
+  trace: Trace
+) => Context;

package/src/trace/trace.service.ts

@@ -0,0 +1,42 @@
+import type { RuntimeInteractRequest, RuntimeInteractResponse } from '@/runtime/runtime.interface.js';
+
+import type { TraceDeclaration, TraceHandlerMeta, TraceOptions } from './trace.interface';
+
+export class TraceService<T = unknown> {
+  private readonly traces: TraceDeclaration<T, any>[] = [];
+
+  public constructor(options: TraceOptions<T> = {}) {
+    this.registerTraces(options.traces ?? []);
+  }
+
+  public registerTrace(step: TraceDeclaration<T, any>): this {
+    this.traces.push(step);
+    return this;
+  }
+
+  public registerTraces(steps: TraceDeclaration<T, any>[]): this {
+    steps.forEach((step) => this.registerTrace(step));
+    return this;
+  }
+
+  public async processTrace(
+    context: T,
+    request: RuntimeInteractRequest,
+    response: RuntimeInteractResponse
+  ): Promise<T> {
+    const meta: TraceHandlerMeta<T> = {
+      request,
+      state: response.state,
+      context,
+    };
+
+    for (const trace of response.trace) {
+      const step = this.traces.find((step) => step.canHandle(trace));
+      if (step) {
+        // eslint-disable-next-line no-await-in-loop
+        meta.context = await step.handle(meta, trace);
+      }
+    }
+    return meta.context;
+  }
+}

package/tsconfig.build.cjs.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./tsconfig.build.json",
+  "compilerOptions": {
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "outDir": "build/cjs"
+  }
+}

package/tsconfig.build.esm.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./tsconfig.build.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "outDir": "build/esm"
+  },
+  "tsc-alias": {
+    "resolveFullPaths": true
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "build", "test", "**/*test.ts", "**/*test-d.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "@voiceflow-meta/typescript-config/base.json",
+  "compilerOptions": {
+    "baseUrl": "./",
+    "outDir": "./build",
+    "stripInternal": true
+  },
+  "include": ["src/**/*", "test"],
+  "exclude": ["node_modules", "build", "src/**/*.test-d.ts"]
+}