@edumalin/platform 3.0.0

package/package.json

@@ -0,0 +1,270 @@
+{
+  "name": "@edumalin/platform",
+  "version": "3.0.0",
+  "description": "Platform libraries for Edumalin",
+  "keywords": [
+    "Edumalin",
+    "functional",
+    "http",
+    "i18n",
+    "reactive",
+    "temporal"
+  ],
+  "author": "Edumalin <dev@edumalin.com>",
+  "contributors": [],
+  "homepage": "https://developer.edumalin.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/edumalin/edumalin.git",
+    "directory": "node/modules/platform"
+  },
+  "bugs": {
+    "url": "https://github.com/edumalin/edumalin/issues"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "node": "./dist/cjs/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/esm/index.js"
+    },
+    "./collection": {
+      "types": "./dist/types/collection/index.d.ts",
+      "node": "./dist/cjs/collection/index.js",
+      "require": "./dist/cjs/collection/index.js",
+      "default": "./dist/esm/collection/index.js"
+    },
+    "./color": {
+      "types": "./dist/types/color/index.d.ts",
+      "node": "./dist/cjs/color/index.js",
+      "require": "./dist/cjs/color/index.js",
+      "default": "./dist/esm/color/index.js"
+    },
+    "./domain": {
+      "types": "./dist/types/domain/index.d.ts",
+      "node": "./dist/cjs/domain/index.js",
+      "require": "./dist/cjs/domain/index.js",
+      "default": "./dist/esm/domain/index.js"
+    },
+    "./environment": {
+      "types": "./dist/types/environment/index.d.ts",
+      "node": "./dist/cjs/environment/index.js",
+      "require": "./dist/cjs/environment/index.js",
+      "default": "./dist/esm/environment/index.js"
+    },
+    "./error": {
+      "types": "./dist/types/error/index.d.ts",
+      "node": "./dist/cjs/error/index.js",
+      "require": "./dist/cjs/error/index.js",
+      "default": "./dist/esm/error/index.js"
+    },
+    "./event": {
+      "types": "./dist/types/event/index.d.ts",
+      "node": "./dist/cjs/event/index.js",
+      "require": "./dist/cjs/event/index.js",
+      "default": "./dist/esm/event/index.js"
+    },
+    "./functional": {
+      "types": "./dist/types/functional/index.d.ts",
+      "node": "./dist/cjs/functional/index.js",
+      "require": "./dist/cjs/functional/index.js",
+      "default": "./dist/esm/functional/index.js"
+    },
+    "./http": {
+      "types": "./dist/types/http/index.d.ts",
+      "node": "./dist/cjs/http/index.js",
+      "require": "./dist/cjs/http/index.js",
+      "default": "./dist/esm/http/index.js"
+    },
+    "./http/client": {
+      "types": "./dist/types/http/client/index.d.ts",
+      "node": "./dist/cjs/http/client/index.js",
+      "require": "./dist/cjs/http/client/index.js",
+      "default": "./dist/esm/http/client/index.js"
+    },
+    "./http/client/graphql": {
+      "types": "./dist/types/http/client/graphql/index.d.ts",
+      "node": "./dist/cjs/http/client/graphql/index.js",
+      "require": "./dist/cjs/http/client/graphql/index.js",
+      "default": "./dist/esm/http/client/graphql/index.js"
+    },
+    "./http/client/testing": {
+      "types": "./dist/types/http/client/testing/index.d.ts",
+      "node": "./dist/cjs/http/client/testing/index.js",
+      "require": "./dist/cjs/http/client/testing/index.js",
+      "default": "./dist/esm/http/client/testing/index.js"
+    },
+    "./geometry": {
+      "types": "./dist/types/geometry/index.d.ts",
+      "node": "./dist/cjs/geometry/index.js",
+      "require": "./dist/cjs/geometry/index.js",
+      "default": "./dist/esm/geometry/index.js"
+    },
+    "./i18n": {
+      "types": "./dist/types/i18n/index.d.ts",
+      "node": "./dist/cjs/i18n/index.js",
+      "require": "./dist/cjs/i18n/index.js",
+      "default": "./dist/esm/i18n/index.js"
+    },
+    "./language": {
+      "types": "./dist/types/language/index.d.ts",
+      "node": "./dist/cjs/language/index.js",
+      "require": "./dist/cjs/language/index.js",
+      "default": "./dist/esm/language/index.js"
+    },
+    "./locale": {
+      "types": "./dist/types/locale/index.d.ts",
+      "node": "./dist/cjs/locale/index.js",
+      "require": "./dist/cjs/locale/index.js",
+      "default": "./dist/esm/locale/index.js"
+    },
+    "./random": {
+      "types": "./dist/types/random/index.d.ts",
+      "node": "./dist/cjs/random/index.js",
+      "require": "./dist/cjs/random/index.js",
+      "default": "./dist/esm/random/index.js"
+    },
+    "./reactive": {
+      "types": "./dist/types/reactive/index.d.ts",
+      "node": "./dist/cjs/reactive/index.js",
+      "require": "./dist/cjs/reactive/index.js",
+      "default": "./dist/esm/reactive/index.js"
+    },
+    "./reactive/polyfill": {
+      "types": "./dist/types/reactive/polyfill/index.d.ts",
+      "node": "./dist/cjs/reactive/polyfill/index.js",
+      "require": "./dist/cjs/reactive/polyfill/index.js",
+      "default": "./dist/esm/reactive/polyfill/index.js"
+    },
+    "./temporal": {
+      "types": "./dist/types/temporal/index.d.ts",
+      "node": "./dist/cjs/temporal/index.js",
+      "require": "./dist/cjs/temporal/index.js",
+      "default": "./dist/esm/temporal/index.js"
+    },
+    "./temporal/polyfill": {
+      "types": "./dist/types/temporal/polyfill/index.d.ts",
+      "node": "./dist/cjs/temporal/polyfill/index.js",
+      "require": "./dist/cjs/temporal/polyfill/index.js",
+      "default": "./dist/esm/temporal/polyfill/index.js"
+    },
+    "./testing": {
+      "types": "./dist/types/testing/index.d.ts",
+      "node": "./dist/cjs/testing/index.js",
+      "require": "./dist/cjs/testing/index.js",
+      "default": "./dist/esm/testing/index.js"
+    },
+    "./typescript": {
+      "types": "./dist/types/typescript/index.d.ts",
+      "node": "./dist/cjs/typescript/index.js",
+      "require": "./dist/cjs/typescript/index.js",
+      "default": "./dist/esm/typescript/index.js"
+    },
+    "./url": {
+      "types": "./dist/types/url/index.d.ts",
+      "node": "./dist/cjs/url/index.js",
+      "require": "./dist/cjs/url/index.js",
+      "default": "./dist/esm/url/index.js"
+    },
+    "./uuid": {
+      "types": "./dist/types/uuid/index.d.ts",
+      "node": "./dist/cjs/uuid/index.js",
+      "require": "./dist/cjs/uuid/index.js",
+      "default": "./dist/esm/uuid/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "collection": [
+        "dist/types/collection/index.d.ts"
+      ],
+      "color": [
+        "dist/types/color/index.d.ts"
+      ],
+      "domain": [
+        "dist/types/domain/index.d.ts"
+      ],
+      "environment": [
+        "dist/types/environment/index.d.ts"
+      ],
+      "error": [
+        "dist/types/error/index.d.ts"
+      ],
+      "event": [
+        "dist/types/event/index.d.ts"
+      ],
+      "functional": [
+        "dist/types/functional/index.d.ts"
+      ],
+      "http": [
+        "dist/types/http/index.d.ts"
+      ],
+      "geometry": [
+        "dist/types/geometry/index.d.ts"
+      ],
+      "i18n": [
+        "dist/types/i18n/index.d.ts"
+      ],
+      "language": [
+        "dist/types/language/index.d.ts"
+      ],
+      "locale": [
+        "dist/types/locale/index.d.ts"
+      ],
+      "random": [
+        "dist/types/random/index.d.ts"
+      ],
+      "reactive": [
+        "dist/types/reactive/index.d.ts"
+      ],
+      "temporal": [
+        "dist/types/temporal/index.d.ts"
+      ],
+      "testing": [
+        "dist/types/testing/index.d.ts"
+      ],
+      "typescript": [
+        "dist/types/typescript/index.d.ts"
+      ],
+      "url": [
+        "dist/types/url/index.d.ts"
+      ],
+      "uuid": [
+        "dist/types/uuid/index.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist/cjs/**/!(*.tsbuildinfo)",
+    "dist/esm/**/!(*.tsbuildinfo)",
+    "dist/types/**/!(*.tsbuildinfo)",
+    "src",
+    "LICENSE.md",
+    "package.json",
+    "README.md",
+    "tsconfig.json"
+  ],
+  "sideEffects": [
+    "./dist/cjs/reactive/polyfill/index.js",
+    "./dist/esm/reactive/polyfill/index.js",
+    "./dist/cjs/temporal/polyfill/index.js",
+    "./dist/esm/temporal/polyfill/index.js"
+  ],
+  "dependencies": {},
+  "devDependencies": {},
+  "peerDependencies": {
+    "rxjs": "^7.8.2",
+    "temporal-polyfill": "^0.3.0"
+  },
+  "optionalDependencies": {},
+  "scripts": {
+    "compile": "tsc -b ./src/tsconfig.cjs.json ./src/tsconfig.esm.json ./src/tsconfig.types.json",
+    "lint": "oxlint .",
+    "test": "vitest run",
+    "test:serve": "vitest"
+  }
+}

package/src/collection/array/array-to-deduplicated-array-options.ts

@@ -0,0 +1,13 @@
+/**
+ * Array to deduplicated array options
+ */
+export interface ArrayToDeduplicatedArrayOptions<T, U = T> {
+  /**
+   * Key selector
+   */
+  readonly keySelector?: (item: T) => unknown;
+  /**
+   * Value selector
+   */
+  readonly valueSelector?: (item: T) => U;
+}

package/src/collection/array/array-to-deduplicated-array.ts

@@ -0,0 +1,29 @@
+import { type ArrayToDeduplicatedArrayOptions } from './array-to-deduplicated-array-options';
+
+/**
+ * Creates a function that returns an array with deduplicated items
+ *
+ * @param keySelector Key selector
+ * @returns Function that returns an array with deduplicated items
+ */
+export function arrayToDeduplicatedArray<T, U = T>(
+  options: ArrayToDeduplicatedArrayOptions<T, U>
+): (array: ReadonlyArray<T>) => Array<U> {
+  const { keySelector, valueSelector } = options;
+
+  if (keySelector !== undefined) {
+    return array => {
+      const entries = array.map(item => [keySelector(item), item as unknown as U] as const);
+      const map = new Map(entries);
+      return Array.from(map.values());
+    };
+  } else if (valueSelector !== undefined) {
+    return array => {
+      const values = array.map(valueSelector);
+      const set = new Set(values);
+      return Array.from(set);
+    };
+  } else {
+    throw new Error(`a key or value selector must be provided`);
+  }
+}

package/src/collection/array/array-to-element-at.ts

@@ -0,0 +1,9 @@
+/**
+ * Creates a function that returns an array's element
+ *
+ * @param index Element index
+ * @returns Function that returns an array's element
+ */
+export function arrayToElementAt(index: number): <T>(array: ReadonlyArray<T>) => T | undefined {
+  return array => array[index];
+}

package/src/collection/array/array-to-first-element.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns an array's first element
+ *
+ * @param array Array
+ * @returns First element
+ */
+export function arrayToFirstElement<T>(array: ReadonlyArray<T>): T | undefined {
+  return array[0];
+}

package/src/collection/array/array-to-flattened-array.spec.ts

@@ -0,0 +1,8 @@
+import { describe, it } from 'vitest';
+
+import { arrayToFlattenedArray } from './array-to-flattened-array.js';
+
+describe('Array to flattened array', () => {
+  arrayToFlattenedArray;
+  it.todo('works');
+});

package/src/collection/array/array-to-flattened-array.ts

@@ -0,0 +1,11 @@
+/**
+ * Creates a function that flattens an array up to a specific depth
+ *
+ * @param depth Depth (defaults to 1)
+ * @returns Function that flattens an array up to the specified depth
+ */
+export function arrayToFlattenedArray<Depth extends number = 1>(
+  depth?: Depth
+): <ArrayType extends ReadonlyArray<unknown>>(array: ArrayType) => Array<FlatArray<ArrayType, Depth>> {
+  return array => array.flat(depth);
+}

package/src/collection/array/array-to-slices.spec.ts

@@ -0,0 +1,7 @@
+import { describe, it } from 'vitest';
+
+//import { arrayToSlices } from './array-to-slices.js';
+
+describe('Array to slices', () => {
+  it.todo('TODO');
+});

package/src/collection/array/array-to-slices.ts

@@ -0,0 +1,18 @@
+/**
+ * Creates a function that turns an array into a list of array slices with a maximum size
+ *
+ * @param sliceSize Maximum size of a slice
+ * @returns Function that turns an array into a list of array slices of maximum size `sliceSize`
+ */
+export function arrayToSlices(sliceSize: number): <T>(array: ReadonlyArray<T>) => Array<Array<T>> {
+  return <T>(array: ReadonlyArray<T>) => {
+    const chunks: Array<Array<T>> = [];
+
+    for (let start = 0; start < array.length; start += sliceSize) {
+      const chunk = array.slice(start, start + sliceSize);
+      chunks.push(chunk);
+    }
+
+    return chunks;
+  };
+}

package/src/collection/buffer/buffer-to-string-options.ts

@@ -0,0 +1,9 @@
+/**
+ * Buffer to string options
+ */
+export interface BufferToStringOptions {
+  /**
+   * Encoding
+   */
+  readonly encoding: 'utf-8';
+}

package/src/collection/buffer/buffer-to-string.ts

@@ -0,0 +1,13 @@
+import { type BufferToStringOptions } from './buffer-to-string-options.js';
+
+/**
+ * Creates a function that decodes a buffer into a string
+ *
+ * @param options Options
+ * @returns Function that decodes a buffer into a string
+ */
+export function bufferToString(options: BufferToStringOptions): (buffer: AllowSharedBufferSource) => string {
+  const { encoding } = options;
+  const textDecoder = new TextDecoder(encoding, { ignoreBOM: true });
+  return buffer => textDecoder.decode(buffer);
+}

package/src/collection/each.spec.ts

@@ -0,0 +1,8 @@
+import { describe, it } from 'vitest';
+
+import { each } from './each.js';
+
+describe('Each', () => {
+  each;
+  it.todo('works');
+});

package/src/collection/each.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates a function that maps an array's items
+ *
+ * @param project Projection function
+ * @returns Function that maps an array's items
+ * @template T Value type
+ * @template U Result type
+ */
+export function each<T, U>(project: (value: T, index: number) => U): (array: ReadonlyArray<T>) => Array<U> {
+  // TODO: ReadonlyMap and ReadonlySet
+  return array => array.map(project);
+}

package/src/collection/included-in.ts

@@ -0,0 +1,12 @@
+/**
+ * Creates a function that returns whether a value is included in a list, set or map
+ *
+ * @param values List of values
+ * @returns Function that returns whether a value is included in a list, set or map
+ * @template T Value type
+ */
+export function includedIn<T>(
+  values: ReadonlyArray<T> | ReadonlySet<T> | ReadonlyMap<T, unknown>
+): (value: T) => boolean {
+  return 'size' in values ? value => values.has(value) : value => values.includes(value);
+}

package/src/collection/index.ts

@@ -0,0 +1,10 @@
+export { arrayToDeduplicatedArray } from './array/array-to-deduplicated-array.js';
+export { arrayToElementAt } from './array/array-to-element-at.js';
+export { arrayToFirstElement } from './array/array-to-first-element.js';
+export { arrayToFlattenedArray } from './array/array-to-flattened-array.js';
+export { arrayToSlices } from './array/array-to-slices.js';
+export { bufferToString } from './buffer/buffer-to-string.js';
+export { type BufferToStringOptions } from './buffer/buffer-to-string-options.js';
+export { each } from './each.js';
+export { includedIn } from './included-in.js';
+export { stringToLineStream } from './string/string-to-line-stream.js';

package/src/collection/string/string-to-line-stream.spec.ts

@@ -0,0 +1,21 @@
+import { firstValueFrom, toArray } from 'rxjs';
+import { describe, expect, it } from 'vitest';
+
+import { stringToLineStream } from './string-to-line-stream.js';
+
+describe('String to line stream', () => {
+  it('can create a line stream that emits one line from a string at a time', async () => {
+    // given: a string with multiple lines
+    const line1 = 'test line 1';
+    const line2 = 'test line 2';
+    const str = [line1, line2].join('\n');
+
+    // when: creating a CSV input stream from the string
+    const inputStream$ = stringToLineStream(str);
+
+    // then: the stream contains the lines
+    const result$ = inputStream$.pipe(toArray());
+    const result = await firstValueFrom(result$);
+    expect(result).toEqual([line1, line2]);
+  });
+});

package/src/collection/string/string-to-line-stream.ts

@@ -0,0 +1,11 @@
+import { defer, from } from 'rxjs';
+
+/**
+ * Creates a line stream from a string, emitting one line at a time
+ *
+ * @param string String
+ * @returns Stream of lines
+ */
+export function stringToLineStream(string: string): Observable<string> {
+  return defer(() => from(string.split('\n')));
+}

package/src/color/color.error.ts

@@ -0,0 +1,14 @@
+import { platformDomain } from '@edumalin/platform';
+import { createErrorType, errorProperties } from '@edumalin/platform/error';
+
+import { type InvalidColorStringErrorProperties } from './error/invalid-color-string-error-properties.js';
+
+/**
+ * Color error
+ */
+export const colorError = createErrorType(platformDomain, {
+  /**
+   * Invalid color string
+   */
+  invalidColorString: errorProperties<InvalidColorStringErrorProperties>(),
+});

package/src/color/error/invalid-color-string-error-properties.ts

@@ -0,0 +1,6 @@
+/**
+ * Invalid color string error properties
+ */
+export interface InvalidColorStringErrorProperties {
+  readonly value: unknown;
+}

package/src/color/index.ts

@@ -0,0 +1,6 @@
+export { asColorString } from './string/as-color-string.js';
+export { colorError } from './color.error.js';
+export { type ColorString } from './string/color-string.js';
+export { generateColorString } from './string/generate-color-string.js';
+export { isColorString } from './string/is-color-string.js';
+export { validateColorString } from './string/validate-color-string.js';

package/src/color/string/as-color-string.spec.ts

@@ -0,0 +1,8 @@
+import { describe, it } from 'vitest';
+
+import { asColorString } from './as-color-string.js';
+
+describe('As color string', () => {
+  asColorString;
+  it.todo('works');
+});

package/src/color/string/as-color-string.ts

@@ -0,0 +1,13 @@
+import { type ColorString } from './color-string.js';
+import { validateColorString } from './validate-color-string.js';
+
+/**
+ * Safely casts a value to a color string
+ *
+ * @param value Value
+ * @returns Color string
+ */
+export function asColorString(value: unknown): ColorString {
+  validateColorString(value);
+  return value;
+}

package/src/color/string/color-string.ts

@@ -0,0 +1,6 @@
+/**
+ * Color string
+ */
+export type ColorString = string & {
+  readonly __tag_platformColorString: unique symbol;
+};

package/src/color/string/generate-color-string.ts

@@ -0,0 +1,16 @@
+import { asColorString } from './as-color-string.js';
+import { type ColorString } from './color-string.js';
+
+/**
+ * Generates a random color string
+ *
+ * @returns Random color string
+ */
+export function generateColorString(): ColorString {
+  const hexColor = Array.from({ length: 3 }, () => Math.random() * 256)
+    .map(Math.floor)
+    .map(value => value.toString(16))
+    .map(value => value.padStart(2, '0'))
+    .join('');
+  return asColorString('#' + hexColor);
+}

package/src/color/string/is-color-string.spec.ts

@@ -0,0 +1,8 @@
+import { describe, it } from 'vitest';
+
+import { isColorString } from './is-color-string.js';
+
+describe('Is color string', () => {
+  isColorString;
+  it.todo('works');
+});

package/src/color/string/is-color-string.ts

@@ -0,0 +1,13 @@
+import { type ColorString } from './color-string.js';
+
+/**
+ * Tests whether a value is a color string
+ *
+ * @param value Value
+ * @returns true if the value is a color string
+ */
+export function isColorString(value: unknown): value is ColorString {
+  return typeof value === 'string' && regExp.test(value);
+}
+
+const regExp = /^#[0-9a-f]{6}$/;

package/src/color/string/validate-color-string.spec.ts

@@ -0,0 +1,8 @@
+import { describe, it } from 'vitest';
+
+import { validateColorString } from './validate-color-string.js';
+
+describe('Validate color string', () => {
+  validateColorString;
+  it.todo('works');
+});

package/src/color/string/validate-color-string.ts

@@ -0,0 +1,14 @@
+import { colorError } from '../color.error.js';
+import { type ColorString } from './color-string.js';
+import { isColorString } from './is-color-string.js';
+
+/**
+ * Validates that a value is a color string
+ *
+ * @param value Value
+ */
+export function validateColorString(value: unknown): asserts value is ColorString {
+  if (!isColorString(value)) {
+    throw colorError.invalidColorString({ value });
+  }
+}

package/src/domain/create-domain.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, expectTypeOf, it } from 'vitest';
+
+import { createDomain } from './create-domain.js';
+import { type Domain } from './domain.js';
+
+describe('Create domain', () => {
+  it('creates a domain', () => {
+    // given: a domain name
+    const domainName = '@test/domain';
+
+    // when: creating a domain
+    const domain = createDomain(domainName);
+
+    // then: the domain object is correctly built
+    expect(domain.name).toBe(domainName);
+    expectTypeOf(domain).toEqualTypeOf<Domain<typeof domainName>>();
+  });
+});

package/src/domain/create-domain.ts

@@ -0,0 +1,14 @@
+import { type Domain } from './domain.js';
+
+/**
+ * Creates a domain
+ *
+ * @param domainName Domain name
+ * @returns Domain
+ * @template DomainName Domain name
+ */
+export function createDomain<DomainName extends string>(domainName: DomainName): Domain<DomainName> {
+  return {
+    name: domainName,
+  };
+}