@goast/core 0.4.1 → 0.5.0-beta.1

package/src/src/utils/action-provider.ts

@@ -1,58 +0,0 @@
-// deno-lint-ignore-file
-import type { EmptyConstructor, FunctionNames } from './type.utils.js';
-
-type MatchingFunctionNames<T, TAction> = {
-  [K in keyof T]: T[K] extends TAction ? K : never;
-}[keyof T];
-
-type CtorActionRunner<T, TAction> = {
-  kind: 'ctor';
-  factory: EmptyConstructor<T>;
-  functionName: MatchingFunctionNames<T, TAction>;
-};
-
-type FnActionRunner<TAction> = {
-  kind: 'fn';
-  action: TAction;
-};
-
-type ValueActionRunner<T, TAction> = {
-  kind: 'value';
-  value: T;
-  functionName: MatchingFunctionNames<T, TAction>;
-};
-
-type ActionRunner<TAction> = CtorActionRunner<any, TAction> | FnActionRunner<TAction> | ValueActionRunner<any, TAction>;
-
-export class ActionProvider<TAction extends (...args: any[]) => any> {
-  constructor(private readonly _runner: ActionRunner<TAction>) {}
-
-  public run(...args: Parameters<TAction>): ReturnType<TAction> {
-    switch (this._runner.kind) {
-      case 'ctor':
-        return new this._runner.factory()[this._runner.functionName as any](...args);
-      case 'fn':
-        return this._runner.action(...args);
-      case 'value':
-        return this._runner.value[this._runner.functionName as any](...args);
-    }
-  }
-
-  public static fromType<T, TName extends FunctionNames<T>>(
-    type: EmptyConstructor<T>,
-    functionName: TName,
-  ): ActionProvider<T[TName] extends (...args: any[]) => any ? T[TName] : never> {
-    return new ActionProvider({ kind: 'ctor', factory: type, functionName: functionName as any });
-  }
-
-  public static fromFn<TAction extends (...args: any[]) => any>(fn: TAction): ActionProvider<TAction> {
-    return new ActionProvider({ kind: 'fn', action: fn });
-  }
-
-  public static fromValue<T, TName extends FunctionNames<T>>(
-    value: T,
-    functionName: TName,
-  ): ActionProvider<T[TName] extends (...args: any[]) => any ? T[TName] : never> {
-    return new ActionProvider({ kind: 'value', value, functionName: functionName as any });
-  }
-}

package/src/src/utils/array.utils.ts

@@ -1,7 +0,0 @@
-export function removeItems<T>(array: T[], predicate: (item: T) => boolean): void {
-  for (let i = array.length - 1; i >= 0; i--) {
-    if (predicate(array[i])) {
-      array.splice(i, 1);
-    }
-  }
-}

package/src/src/utils/asset-manager.ts

@@ -1,51 +0,0 @@
-import * as dntShim from "../../_dnt.shims.js";
-import { basename, resolve } from 'node:path';
-import { fileURLToPath, URL } from 'node:url';
-
-
-import fs from 'fs-extra';
-
-export class AssetManager {
-  private readonly _assetsBaseUrl: URL;
-
-  constructor(assetsBaseUrl: URL) {
-    this._assetsBaseUrl = assetsBaseUrl;
-  }
-
-  public async getAssetFileContent(relativePath: string): Promise<string> {
-    if (this._assetsBaseUrl.protocol === 'file:') {
-      return await fs.readFile(resolve(fileURLToPath(this._assetsBaseUrl), relativePath), 'utf8');
-    } else {
-      return await this.fetchAssetFile(relativePath);
-    }
-  }
-
-  public async copyAssetFile(relativePath: string, destDir: string, logName?: string): Promise<void> {
-    const targetPath = resolve(destDir, basename(relativePath));
-    if (logName !== undefined) {
-      if (logName) {
-        console.log(`Copying ${logName} to "${targetPath}"`);
-      } else {
-        console.log(`Copying asset file "${relativePath}" to "${targetPath}"`);
-      }
-    }
-    if (this._assetsBaseUrl.protocol === 'file:') {
-      const srcPath = resolve(fileURLToPath(this._assetsBaseUrl), relativePath);
-      await fs.copyFile(srcPath, targetPath);
-    } else {
-      const fileContent = await this.fetchAssetFile(relativePath);
-      await fs.outputFile(targetPath, fileContent);
-    }
-  }
-
-  private async fetchAssetFile(relativePath: string): Promise<string> {
-    const url = new URL(relativePath, this._assetsBaseUrl);
-    const response = await dntShim.fetch(url);
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch asset file "${relativePath}" from "${url.href}": ${response.statusText} (${response.status})`,
-      );
-    }
-    return await response.text();
-  }
-}

package/src/src/utils/class.utils.ts

@@ -1,40 +0,0 @@
-// deno-lint-ignore-file no-explicit-any
-export function classifyArray<TItem, TClassification extends Record<string, abstract new (...args: any[]) => any>>(
-  items: Iterable<TItem>,
-  classification: TClassification,
-): { [P in keyof TClassification]: InstanceType<TClassification[P]>[] } & {
-  rest: Exclude<TItem, InstanceType<TClassification[string]>>[];
-} {
-  const result = { rest: [] } as { [P in keyof TClassification]: InstanceType<TClassification[P]>[] } & {
-    rest: Exclude<TItem, InstanceType<TClassification[string]>>[];
-  };
-
-  for (const key in classification) {
-    (result as any)[key] = [];
-  }
-
-  for (const item of items) {
-    let classified = false;
-    for (const key in classification) {
-      const type = classification[key];
-      if (item instanceof type) {
-        result[key].push(item as any);
-        classified = true;
-        break;
-      }
-    }
-    if (!classified) {
-      result.rest.push(item as any);
-    }
-  }
-
-  return result;
-}
-
-export function isInstanceOf<T>(item: unknown, type: abstract new (...args: any[]) => T): item is T {
-  return item instanceof type;
-}
-
-export function getIsInstanceOf<T>(type: abstract new (...args: any[]) => T): (item: unknown) => item is T {
-  return (item): item is T => item instanceof type;
-}

package/src/src/utils/common.utils.test.ts

@@ -1,22 +0,0 @@
-import "../../_dnt.test_polyfills.js";
-import { expect } from '../../deps/jsr.io/@std/expect/1.0.12/mod.js';
-import { describe, test } from '../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-
-import { isNullish } from './common.utils.js';
-
-describe('isNullish', () => {
-  test('returns true for null', () => {
-    expect(isNullish(null)).toBe(true);
-  });
-
-  test('returns true for undefined', () => {
-    expect(isNullish(undefined)).toBe(true);
-  });
-
-  test('returns false for any other value', () => {
-    expect(isNullish('')).toBe(false);
-    expect(isNullish(false)).toBe(false);
-    expect(isNullish(0)).toBe(false);
-    expect(isNullish({})).toBe(false);
-  });
-});

package/src/src/utils/common.utils.ts

@@ -1,86 +0,0 @@
-import type { SingleOrMultiple } from './type.utils.js';
-
-export function isNullish(value: unknown): value is null | undefined {
-  return value === null || value === undefined;
-}
-
-export function notNullish<T>(value: T): value is NonNullable<T> {
-  return !isNullish(value);
-}
-
-export function concatSingleOrMultiple<T>(...values: SingleOrMultiple<T>[]): SingleOrMultiple<T> {
-  if (values.length === 1) {
-    return values[0];
-  }
-  const result: T[] = [];
-  for (const value of values) {
-    if (Array.isArray(value)) {
-      result.push(...value);
-    } else {
-      result.push(value);
-    }
-  }
-  return result;
-}
-
-export function isIterable(value: unknown): value is Iterable<unknown> {
-  return typeof value === 'object' && value !== null && Symbol.iterator in value;
-}
-
-export function toArray<T>(value: T | T[] | Iterable<T>): T[] {
-  if (Array.isArray(value)) {
-    return value;
-  }
-  if (isIterable(value)) {
-    return Array.from(value);
-  }
-  return [value];
-}
-
-export function modify<T>(value: T, callback: (value: NonNullable<T>) => void): T {
-  if (notNullish(value)) {
-    callback(value);
-  }
-  return value;
-}
-
-export function run<T>(value: T, callback: (value: T) => void): T {
-  callback(value);
-  return value;
-}
-
-export function transform<T, U>(value: T, callback: (value: T) => U): U {
-  return callback(value);
-}
-
-type IterableItem<T> = T extends Iterable<infer U> ? U : never;
-export function modifyEach<T extends Iterable<unknown>>(
-  values: T,
-  callback: (value: NonNullable<IterableItem<T>>) => void,
-): T {
-  for (const value of values) {
-    if (notNullish(value)) {
-      callback(value as NonNullable<IterableItem<T>>);
-    }
-  }
-  return values;
-}
-
-export function runEach<T extends Iterable<unknown>>(values: T, callback: (value: IterableItem<T>) => void): T {
-  for (const value of values) {
-    callback(value as IterableItem<T>);
-  }
-  return values;
-}
-
-export function transformEach<T, U>(values: Iterable<T>, callback: (value: T) => U): U[] {
-  const result: U[] = [];
-  for (const value of values) {
-    result.push(callback(value));
-  }
-  return result;
-}
-
-export function asVoid(_: unknown): void {
-  // Do nothing
-}

package/src/src/utils/condition.test.ts

@@ -1,36 +0,0 @@
-import "../../_dnt.test_polyfills.js";
-import { expect, fn } from '../../deps/jsr.io/@std/expect/1.0.12/mod.js';
-import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-
-import { type Condition, evalCondition } from './condition.js';
-
-describe('evalCondition', () => {
-  it('should return the correct boolean value when condition is true', () => {
-    const condition: Condition = true;
-    const result = evalCondition(condition);
-    expect(result).toBe(true);
-  });
-
-  it('should return the correct boolean value when condition is false', () => {
-    const condition: Condition = false;
-    const result = evalCondition(condition);
-    expect(result).toBe(false);
-  });
-
-  it('should call the condition function and return the correct boolean value without context', () => {
-    const condition = fn(() => true) as Condition;
-    const result = evalCondition(condition);
-    expect(result).toBe(true);
-    expect(condition).toHaveBeenCalledTimes(1);
-  });
-
-  it('should call the condition function with the provided context and return the correct boolean value', () => {
-    const context = {
-      prop: 5,
-    };
-    const condition = fn((ctx: typeof context) => ctx.prop === 5) as Condition<typeof context>;
-    const result = evalCondition(condition, context);
-    expect(result).toBe(true);
-    expect(condition).toHaveBeenCalledWith(context);
-  });
-});

package/src/src/utils/condition.ts

@@ -1,7 +0,0 @@
-export type Condition<T = never> = boolean | ([T] extends [never] ? () => boolean : (ctx: T) => boolean);
-export function evalCondition(condition: Condition<never>): boolean;
-export function evalCondition<T>(condition: Condition<T>, ctx: T): boolean;
-export function evalCondition<T>(condition: Condition<T>, ctx?: T): boolean {
-  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-  return typeof condition === 'function' ? condition(ctx!) : condition;
-}

package/src/src/utils/endpoint.utils.test.ts

@@ -1,36 +0,0 @@
-import "../../_dnt.test_polyfills.js";
-import { expect } from '../../deps/jsr.io/@std/expect/1.0.12/mod.js';
-import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-
-import type { ApiEndpoint } from '../transform/api-types.js';
-import { getEndpointUrlPreview } from './endpoint.utils.js';
-
-describe('getEndpointUrlPreview', () => {
-  it('should return the endpoint path if there are no query parameters', () => {
-    const endpoint = { path: '/foo', parameters: [] } as unknown as ApiEndpoint;
-    expect(getEndpointUrlPreview(endpoint)).toBe('/foo');
-  });
-
-  it('should append query parameters to the endpoint path', () => {
-    const endpoint = {
-      path: '/foo',
-      parameters: [
-        { name: 'bar', target: 'query', required: true },
-        { name: 'baz', target: 'query', required: false },
-      ],
-    } as unknown as ApiEndpoint;
-    expect(getEndpointUrlPreview(endpoint)).toBe('/foo?bar={bar}&[baz={baz}]');
-  });
-
-  it('should handle multiple query parameters', () => {
-    const endpoint = {
-      path: '/foo',
-      parameters: [
-        { name: 'bar', target: 'query', required: true },
-        { name: 'baz', target: 'query', required: false },
-        { name: 'qux', target: 'query', required: true },
-      ],
-    } as unknown as ApiEndpoint;
-    expect(getEndpointUrlPreview(endpoint)).toBe('/foo?bar={bar}&[baz={baz}]&qux={qux}');
-  });
-});

package/src/src/utils/endpoint.utils.ts

@@ -1,10 +0,0 @@
-import type { ApiEndpoint } from '../transform/api-types.js';
-
-export function getEndpointUrlPreview(endpoint: ApiEndpoint): string {
-  let url = endpoint.path;
-  const queryParams = endpoint.parameters.filter((p) => p.target === 'query');
-  if (queryParams.length > 0) {
-    url += '?' + queryParams.map((p) => (p.required ? `${p.name}={${p.name}}` : `[${p.name}={${p.name}}]`)).join('&');
-  }
-  return url;
-}

package/src/src/utils/error.utils.ts

@@ -1,3 +0,0 @@
-export function throwExp(message: string): never {
-  throw new Error(message);
-}

package/src/src/utils/factory.test.ts

@@ -1,31 +0,0 @@
-import "../../_dnt.test_polyfills.js";
-import { expect } from '../../deps/jsr.io/@std/expect/1.0.12/mod.js';
-import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-
-import { Factory } from './factory.js';
-
-describe('Factory', () => {
-  describe('create', () => {
-    it('should create an instance using a constructor', () => {
-      class Foo {
-        constructor(public readonly value: string) {}
-      }
-      const factory = Factory.fromType(Foo);
-      const instance = factory.create('bar');
-      expect(instance).toBeInstanceOf(Foo);
-      expect(instance.value).toBe('bar');
-    });
-
-    it('should create an instance using a factory function', () => {
-      const factory = Factory.fromFn((value: string) => ({ value }));
-      const instance = factory.create('bar');
-      expect(instance).toEqual({ value: 'bar' });
-    });
-
-    it('should return a value', () => {
-      const factory = Factory.fromValue('foo');
-      const instance = factory.create();
-      expect(instance).toBe('foo');
-    });
-  });
-});

package/src/src/utils/factory.ts

@@ -1,42 +0,0 @@
-import type { Constructor } from './type.utils.js';
-
-type FactoryProvider<T, TArgs extends unknown[]> =
-  | {
-    kind: 'ctor';
-    factory: Constructor<T, TArgs>;
-  }
-  | {
-    kind: 'fn';
-    factory: (...args: TArgs) => T;
-  }
-  | {
-    kind: 'value';
-    factory: T;
-  };
-
-export class Factory<T, TArgs extends unknown[]> {
-  constructor(private readonly _provider: FactoryProvider<T, TArgs>) {}
-
-  public create(...args: TArgs): T {
-    switch (this._provider.kind) {
-      case 'ctor':
-        return new this._provider.factory(...args);
-      case 'fn':
-        return this._provider.factory(...args);
-      case 'value':
-        return this._provider.factory;
-    }
-  }
-
-  public static fromType<T, TArgs extends unknown[]>(type: Constructor<T, TArgs>): Factory<T, TArgs> {
-    return new Factory({ kind: 'ctor', factory: type });
-  }
-
-  public static fromFn<T, TArgs extends unknown[]>(fn: (...args: TArgs) => T): Factory<T, TArgs> {
-    return new Factory({ kind: 'fn', factory: fn });
-  }
-
-  public static fromValue<T>(value: T): Factory<T, []> {
-    return new Factory({ kind: 'value', factory: value });
-  }
-}

package/src/src/utils/file-system.utils.ts

@@ -1,48 +0,0 @@
-import { resolve } from 'node:path';
-
-
-import fs from 'fs-extra';
-
-import type { Nullable } from './type.utils.js';
-
-export type DirectoryScanOptions = {
-  recursive: boolean;
-  maxDepth: Nullable<number>;
-  filter?: (file: string) => boolean;
-};
-
-export const defaultDirectoryScanOptions: DirectoryScanOptions = {
-  recursive: false,
-  maxDepth: 5,
-};
-
-export async function getFiles(dir: string, options?: Partial<DirectoryScanOptions>): Promise<string[]> {
-  const opts = { ...defaultDirectoryScanOptions, ...options };
-  const files: string[] = [];
-  await getFilesImpl(dir, opts, files, 0);
-  return files;
-}
-
-async function getFilesImpl(
-  dir: string,
-  options: DirectoryScanOptions,
-  files: string[],
-  currentDepth: number,
-): Promise<void> {
-  const dirFiles = await fs.readdir(dir);
-  for (const file of dirFiles) {
-    const filePath = resolve(dir, file);
-    const stat = await fs.lstat(filePath);
-    if (stat.isDirectory()) {
-      if (options.recursive) {
-        if (options.maxDepth && options.maxDepth > currentDepth) {
-          getFilesImpl(filePath, options, files, currentDepth + 1);
-        }
-      }
-    } else {
-      if (!options.filter || options.filter(file)) {
-        files.push(filePath);
-      }
-    }
-  }
-}

package/src/src/utils/generator.utils.test.ts

@@ -1,16 +0,0 @@
-import "../../_dnt.test_polyfills.js";
-import { expect } from '../../deps/jsr.io/@std/expect/1.0.12/mod.js';
-import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-
-import { getInitializedValue } from './generator.utils.js';
-
-describe('getInitializedValue', () => {
-  it('should return the value if it is not undefined', () => {
-    const value = 'test';
-    expect(getInitializedValue(value)).toEqual(value);
-  });
-
-  it('should throw an error if the value is undefined', () => {
-    expect(() => getInitializedValue(undefined)).toThrow('Generator not initialized.');
-  });
-});

package/src/src/utils/generator.utils.ts

@@ -1,6 +0,0 @@
-export function getInitializedValue<T>(value: T | undefined): T {
-  if (value === undefined) {
-    throw new Error('Generator not initialized.');
-  }
-  return value;
-}

package/src/src/utils/object.utils.test.ts

@@ -1,33 +0,0 @@
-import "../../_dnt.test_polyfills.js";
-import { expect } from '../../deps/jsr.io/@std/expect/1.0.12/mod.js';
-import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-
-import { createOverwriteProxy } from './object.utils.js';
-
-describe('createOverwriteProxy', () => {
-  it('should return an object that overwrites specified properties', () => {
-    const obj = { a: 1, b: 2 };
-    const proxy = createOverwriteProxy(obj);
-    proxy.a = 3;
-    expect(proxy.a).toEqual(3);
-    expect(obj.a).toEqual(1);
-  });
-
-  it('should return an object that does not overwrite unspecified properties', () => {
-    const obj = { a: 1, b: 2 };
-    const proxy = createOverwriteProxy(obj);
-    proxy.a = 3;
-    expect(proxy.b).toEqual(2);
-    expect(obj.b).toEqual(2);
-  });
-
-  it('should return an object that gets updates to non overwritten properties', () => {
-    const obj = { a: 1, b: 2 };
-    const proxy = createOverwriteProxy(obj);
-    proxy.a = 3;
-    obj.a = 2;
-    obj.b = 4;
-    expect(proxy.a).toEqual(3);
-    expect(proxy.b).toEqual(4);
-  });
-});

package/src/src/utils/object.utils.ts

@@ -1,32 +0,0 @@
-export function createOverwriteProxy<T extends object>(target: T, values?: Partial<T>): T {
-  const proxy = new Proxy(target, new OverwriteProxyHandler());
-  if (values) {
-    Object.assign(proxy, values);
-  }
-  return proxy;
-}
-
-export function getDeepProperty(obj: object, path: string[]): unknown {
-  let current = obj;
-  for (const key of path) {
-    if (!current || typeof current !== 'object') {
-      return undefined;
-    }
-    // deno-lint-ignore no-explicit-any
-    current = (current as any)[key];
-  }
-  return current;
-}
-
-class OverwriteProxyHandler<T extends object> implements ProxyHandler<T> {
-  private readonly _overwrittenValues: Record<PropertyKey, unknown> = {};
-
-  public get(target: T, prop: PropertyKey): unknown {
-    return this._overwrittenValues[prop] ?? (target as Record<PropertyKey, unknown>)[prop];
-  }
-
-  public set(_target: T, prop: PropertyKey, value: unknown): boolean {
-    this._overwrittenValues[prop] = value;
-    return true;
-  }
-}

package/src/src/utils/schema.utils.test.ts

@@ -1,88 +0,0 @@
-import "../../_dnt.test_polyfills.js";
-import { expect } from '../../deps/jsr.io/@std/expect/1.0.12/mod.js';
-import { describe, it } from '../../deps/jsr.io/@std/testing/1.0.9/bdd.js';
-
-import {
-  createCombinedSchema,
-  createObjectSchema,
-  createStringSchema,
-  createUnknownProperty,
-} from '../../tests/schema-factory.js';
-import { resolveAnyOfAndAllOf } from './schema.utils.js';
-
-describe('resolveAnyOfAndAllOf', () => {
-  it('should return undefined if the schema is not valid for merge and ignoreNonObjectParts is false', () => {
-    const schema = createCombinedSchema({
-      anyOf: [createStringSchema()],
-    });
-
-    const result = resolveAnyOfAndAllOf(schema, false);
-    expect(result).toBeUndefined();
-  });
-
-  it('should resolve schema from allOf and anyOf', () => {
-    const prop0 = createUnknownProperty('prop0');
-    const prop1 = createUnknownProperty('prop1');
-    const prop2 = createUnknownProperty('prop2');
-    const schema = createObjectSchema({
-      name: 'root',
-      properties: [prop0],
-      required: ['prop0'],
-      allOf: [createObjectSchema({ properties: [prop1], required: ['prop1'] })],
-      anyOf: [createObjectSchema({ properties: [prop2], required: ['prop2'] })],
-    });
-
-    const expectedResult = expect.objectContaining(
-      createObjectSchema({
-        name: 'root',
-        properties: [prop0, prop1, prop2],
-        required: ['prop0', 'prop1'],
-      }),
-    );
-
-    const result = resolveAnyOfAndAllOf(schema, true);
-    expect(result).toEqual(expectedResult);
-  });
-
-  it('should merge properties from allOf and anyOf recursively', () => {
-    const prop1 = createUnknownProperty('prop1');
-    const prop2 = createUnknownProperty('prop2');
-    const prop3 = createUnknownProperty('prop3');
-    const schema = createCombinedSchema({
-      name: 'root',
-      allOf: [
-        createObjectSchema({
-          properties: [prop1],
-          required: ['prop1'],
-        }),
-      ],
-      anyOf: [
-        createCombinedSchema({
-          allOf: [
-            createObjectSchema({
-              properties: [prop2],
-              required: ['prop2'],
-            }),
-          ],
-          anyOf: [
-            createObjectSchema({
-              properties: [prop3],
-              required: ['prop3'],
-            }),
-          ],
-        }),
-      ],
-    });
-
-    const expectedResult = expect.objectContaining(
-      createObjectSchema({
-        name: 'root',
-        properties: [prop1, prop2, prop3],
-        required: ['prop1'],
-      }),
-    );
-
-    const result = resolveAnyOfAndAllOf(schema, true);
-    expect(result).toEqual(expectedResult);
-  });
-});