@flowscripter/dynamic-cli-framework 1.4.19 → 1.5.0

package/tests/fixtures/Context.ts

@@ -1,32 +0,0 @@
-import DefaultContext from "../../src/runtime/DefaultContext.ts";
-import { getCLIConfig } from "./CLIConfig.ts";
-import { PRINTER_SERVICE_ID } from "../../src/api/service/core/PrinterService.ts";
-import DefaultPrinterService from "../../src/service/printer/DefaultPrinterService.ts";
-import DefaultKeyValueService from "../../src/service/configuration/DefaultKeyValueService.ts";
-import { KEY_VALUE_SERVICE_ID } from "../../src/api/service/core/KeyValueService.ts";
-import type Context from "../../src/api/Context.ts";
-import WritableStreamString from "./StreamString.ts";
-import TtyTerminal from "../../src/terminal/TtyTerminal.ts";
-import TtyStyler from "../../src/terminal/TtyStyler.ts";
-import { TABLE_GENERATOR_SERVICE_ID } from "../../src/api/service/core/TableGeneratorService.ts";
-import DefaultTableGeneratorService from "../../src/service/tableGenerator/DefaultTableGeneratorService.ts";
-
-export function getContext(streamString: WritableStreamString): Context {
-  const defaultContext = new DefaultContext(getCLIConfig());
-  const defaultPrinterService = new DefaultPrinterService(
-    streamString.writableStream,
-    streamString.writableStream,
-    false,
-    false,
-    new TtyTerminal(streamString.writeStream),
-    new TtyTerminal(streamString.writeStream),
-    new TtyStyler(3),
-  );
-
-  defaultPrinterService.colorEnabled = false;
-  defaultContext.addServiceInstance(PRINTER_SERVICE_ID, defaultPrinterService);
-  defaultContext.addServiceInstance(KEY_VALUE_SERVICE_ID, new DefaultKeyValueService());
-  defaultContext.addServiceInstance(TABLE_GENERATOR_SERVICE_ID, new DefaultTableGeneratorService());
-
-  return defaultContext;
-}

package/tests/fixtures/ServiceProviderRegistry.ts

@@ -1,16 +0,0 @@
-import DefaultServiceProviderRegistry from "../../src/runtime/registry/DefaultServiceProviderRegistry.ts";
-import type ServiceProviderRegistry from "../../src/runtime/registry/ServiceProviderRegistry.ts";
-import type { ServiceProvider } from "../../src/api/service/ServiceProvider.ts";
-
-export function getServiceProviderRegistry(
-  serviceProviders?: Array<ServiceProvider>,
-): ServiceProviderRegistry {
-  const serviceProviderRegistry = new DefaultServiceProviderRegistry([]);
-
-  if (serviceProviders) {
-    serviceProviders.forEach((serviceProvider) =>
-      serviceProviderRegistry.addServiceProvider(serviceProvider),
-    );
-  }
-  return serviceProviderRegistry;
-}

package/tests/fixtures/StreamString.ts

@@ -1,37 +0,0 @@
-import { Buffer } from "node:buffer";
-import { WriteStream } from "node:tty";
-import { PassThrough } from "node:stream";
-import { WritableStream } from "node:stream/web";
-
-export default class WritableStreamString {
-  private chunks: string[];
-  writableStream: WritableStream<Uint8Array>;
-  writeStream: WriteStream;
-
-  constructor() {
-    this.chunks = [];
-
-    this.writableStream = new WritableStream<Uint8Array>({
-      write: (chunk: Uint8Array) => {
-        const decoder = new TextDecoder();
-        const chunkString = decoder.decode(chunk);
-        this.chunks.push(chunkString);
-      },
-    });
-
-    const passThrough = new PassThrough();
-    this.writeStream = passThrough as unknown as WriteStream;
-
-    passThrough.on("data", (chunk) => {
-      if (Buffer.isBuffer(chunk)) {
-        this.chunks.push(chunk.toString());
-      } else {
-        this.chunks.push(String(chunk));
-      }
-    });
-  }
-
-  getString(): string {
-    return this.chunks.join("");
-  }
-}

package/tests/fixtures/prettierPluginFoo.ts

@@ -1,31 +0,0 @@
-import type { Parser, Plugin, Printer, SupportLanguage } from "prettier";
-
-const languages: SupportLanguage[] = [
-  {
-    name: "foo",
-    parsers: ["foo"],
-  },
-];
-
-const parsers: Record<string, Parser> = {
-  foo: {
-    astFormat: "foo",
-    parse: () => "",
-    locStart: () => 0,
-    locEnd: () => 0,
-  },
-};
-
-const printers: Record<string, Printer> = {
-  foo: {
-    print: () => "foo",
-  },
-};
-
-const prettierPluginFoo: Plugin = {
-  languages,
-  parsers,
-  printers,
-};
-
-export default prettierPluginFoo;

package/tests/fixtures/util.ts

@@ -1,35 +0,0 @@
-import { expect } from "bun:test";
-import { stripVTControlCharacters } from "node:util";
-import { WritableStream } from "node:stream/web";
-
-const encoder = new TextEncoder();
-
-export function expectStringIncludes(actual: string, expected: string) {
-  expect(stripVTControlCharacters(actual).includes(expected)).toBeTrue();
-}
-
-export function expectStringNotIncludes(actual: string, expected: string) {
-  expect(stripVTControlCharacters(actual).includes(expected)).toBeFalse();
-}
-
-export function expectStringEquals(actual: string, expected: string) {
-  expect(stripVTControlCharacters(actual)).toEqual(expected);
-}
-
-export function expectBytesEquals(actual: string, expected: Uint8Array) {
-  expect(encoder.encode(actual)).toEqual(expected as Uint8Array<ArrayBuffer>);
-}
-
-export function sleep(ms: number) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export async function write(writableStream: WritableStream, message: string) {
-  const encoded = encoder.encode(message);
-  const writer = writableStream.getWriter();
-
-  await writer.ready;
-  await writer.write(encoded);
-
-  writer.releaseLock();
-}

package/tests/runtime/DefaultContext.test.ts

@@ -1,20 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import DefaultContext from "../../src/runtime/DefaultContext.ts";
-import { getCLIConfig } from "../fixtures/CLIConfig.ts";
-
-describe("DefaultContext tests", () => {
-  test("Check for duplicate service ID", () => {
-    const context = new DefaultContext(getCLIConfig());
-
-    context.addServiceInstance("foo", {});
-    expect(() => context.addServiceInstance("foo", {})).toThrow();
-  });
-
-  test("Check lookup by ID", () => {
-    const context = new DefaultContext(getCLIConfig());
-
-    context.addServiceInstance("foo", "bar");
-
-    expect(context.getServiceById("foo")).toEqual("bar");
-  });
-});

package/tests/runtime/argument/ArgumentTypeGuards.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type ComplexOption from "../../../src/api/argument/ComplexOption.ts";
-import {
-  ArgumentValueTypeName,
-  ComplexValueTypeName,
-} from "../../../src/api/argument/ArgumentValueTypes.ts";
-import type Positional from "../../../src/api/argument/Positional.ts";
-import type GlobalCommandArgument from "../../../src/api/argument/GlobalCommandArgument.ts";
-import { isComplexOption } from "../../../src/runtime/argument/ArgumentTypeGuards.ts";
-import type Option from "../../../src/api/argument/Option.ts";
-
-function getComplexOption(): ComplexOption {
-  return {
-    name: "option",
-    type: ComplexValueTypeName.COMPLEX,
-    properties: [getOption()],
-  };
-}
-
-function getOption(): Option {
-  return {
-    name: "option",
-    type: ArgumentValueTypeName.STRING,
-  };
-}
-
-function getPositional(): Positional {
-  return {
-    name: "positional",
-    type: ArgumentValueTypeName.STRING,
-  };
-}
-
-function getGlobalCommandArgument(): GlobalCommandArgument {
-  return {
-    type: ArgumentValueTypeName.STRING,
-  };
-}
-
-describe("ArgumentTypeGuards tests", () => {
-  test("isComplexOption works", () => {
-    expect(isComplexOption(getComplexOption())).toBeTrue();
-    expect(isComplexOption(getOption())).toBeFalse();
-    expect(isComplexOption(getPositional())).toBeFalse();
-    expect(isComplexOption(getGlobalCommandArgument())).toBeFalse();
-  });
-});

package/tests/runtime/command/CommandTypeGuards.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  getGlobalCommand,
-  getGlobalModifierCommand,
-  getGroupCommand,
-  getSubCommandWithOption,
-} from "../../fixtures/Command.ts";
-import {
-  isGlobalCommand,
-  isGlobalModifierCommand,
-  isGroupCommand,
-  isSubCommand,
-} from "../../../src/runtime/command/CommandTypeGuards.ts";
-
-describe("CommandTypeGuards tests", () => {
-  test("isSubCommand works", () => {
-    expect(isSubCommand(getSubCommandWithOption())).toBeTrue();
-    expect(isSubCommand(getGroupCommand())).toBeFalse();
-    expect(isSubCommand(getGlobalCommand())).toBeFalse();
-    expect(isSubCommand(getGlobalModifierCommand())).toBeFalse();
-  });
-
-  test("isGroupCommand works", () => {
-    expect(isGroupCommand(getSubCommandWithOption())).toBeFalse();
-    expect(isGroupCommand(getGroupCommand())).toBeTrue();
-    expect(isGroupCommand(getGlobalCommand())).toBeFalse();
-    expect(isGroupCommand(getGlobalModifierCommand())).toBeFalse();
-  });
-
-  test("isGlobalCommand works", () => {
-    expect(isGlobalCommand(getSubCommandWithOption())).toBeFalse();
-    expect(isGlobalCommand(getGroupCommand())).toBeFalse();
-    expect(isGlobalCommand(getGlobalCommand())).toBeTrue();
-    expect(isGlobalCommand(getGlobalModifierCommand())).toBeFalse();
-  });
-
-  test("isGlobalModifierCommand works", () => {
-    expect(isGlobalModifierCommand(getSubCommandWithOption())).toBeFalse();
-    expect(isGlobalModifierCommand(getGroupCommand())).toBeFalse();
-    expect(isGlobalModifierCommand(getGlobalCommand())).toBeFalse();
-    expect(isGlobalModifierCommand(getGlobalModifierCommand())).toBeTrue();
-  });
-});