@ts-graphviz/common 0.0.0-pr956-20240225073457

package/src/common.ts

@@ -0,0 +1,5 @@
+export * from './functional.js';
+export * from './types.js';
+export * from './attribute.js';
+export * from './models-context.js';
+export * from './models.js';

package/src/functional.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { filter, map, pipe } from './functional.js';
+
+describe('pipe', () => {
+  const double = (n: number): number => n * 2;
+  const addFive = (n: number): number => n + 5;
+  const substractOne = (n: number): number => n - 1;
+
+  it('should pipe functions', () => {
+    expect(pipe(double, addFive, substractOne)(2)).toEqual(8);
+  });
+});
+
+describe('map', () => {
+  it('should map a list of values', () => {
+    expect(map((n: number) => n * 2)([1, 2, 3])).toEqual([2, 4, 6]);
+  });
+});
+
+describe('filter', () => {
+  it('should filter a list of values', () => {
+    expect(filter((n: number) => n % 2 === 0)([1, 2, 3])).toEqual([2]);
+  });
+});

package/src/functional.ts

@@ -0,0 +1,74 @@
+export type F<A extends any[], O> = (...args: A) => O;
+
+export type IO<I, O> = F<[I], O>;
+
+function _pipe<T extends any[], R>(
+  ...args: [o1: F<T, any>, ...operations: IO<any, any>[]]
+): F<T, R> {
+  const [o1, ...operations] = args;
+  return (...t: T) => operations.reduce((acc, f) => f(acc), o1(...t));
+}
+
+export function pipe<I extends any[], O>(f0: F<I, O>): F<I, O>;
+export function pipe<I extends any[], T1, O>(
+  f0: F<I, T1>,
+  f1: IO<T1, O>,
+): F<I, O>;
+export function pipe<I extends any[], T1, T2, O>(
+  f0: F<I, T1>,
+  f1: IO<T1, T2>,
+  f2: IO<T2, O>,
+): F<I, O>;
+export function pipe<I extends any[], T1, T2, T3, O>(
+  f0: F<I, T1>,
+  f1: IO<T1, T2>,
+  f2: IO<T2, T3>,
+  f3: IO<T3, O>,
+): F<I, O>;
+export function pipe<I extends any[], T1, T2, T3, T4, O>(
+  f0: F<I, T1>,
+  f1: IO<T1, T2>,
+  f2: IO<T2, T3>,
+  f3: IO<T3, T4>,
+  f4: IO<T4, O>,
+): F<I, O>;
+export function pipe<I extends any[], O>(
+  o1: F<I, any>,
+  ...operations: IO<any, any>[]
+): F<I, O> {
+  return _pipe(o1, ...operations);
+}
+
+const defer =
+  <P, A extends any[], R>(fn: (src: P, ...args: A) => R) =>
+  (...args: A) =>
+  (src: P): R =>
+    fn(src, ...args);
+
+const toIterable = <T, TF extends () => IterableIterator<T>>(f: TF) => ({
+  [Symbol.iterator]: f,
+});
+
+export const map = defer(
+  <T, O>(src: Iterable<T>, selector: (item: T) => O): O[] =>
+    Array.from(
+      toIterable(function* () {
+        for (const v of src) {
+          yield selector(v);
+        }
+      }),
+    ),
+);
+
+export const filter = defer(
+  <T>(src: Iterable<T>, pred: (item: T) => boolean): T[] =>
+    Array.from(
+      toIterable(function* () {
+        for (const x of src) {
+          if (pred(x)) {
+            yield x;
+          }
+        }
+      }),
+    ),
+);

package/src/models-context.ts

@@ -0,0 +1,41 @@
+import {
+  EdgeConstructor,
+  NodeConstructor,
+  RootGraphConstructor,
+  SubgraphConstructor,
+} from './models.js';
+
+/**
+ * @group Models Context
+ */
+export interface ModelsContext {
+  Graph: RootGraphConstructor;
+  Digraph: RootGraphConstructor;
+  Subgraph: SubgraphConstructor;
+  Node: NodeConstructor;
+  Edge: EdgeConstructor;
+}
+
+/**
+ * @group Models Context
+ */
+export const RootModelsContext: ModelsContext = Object.seal({
+  // NOTE: RootModelsContext is also initialized after the model class is declared in the 'core/index.js' module.
+  Graph: null,
+  Digraph: null,
+  Subgraph: null,
+  Node: null,
+  Edge: null,
+} as unknown as ModelsContext);
+
+/**
+ * @group Models Context
+ */
+export function createModelsContext(
+  models: Partial<ModelsContext>,
+): ModelsContext {
+  return Object.assign(
+    Object.seal(Object.assign({}, RootModelsContext)),
+    models,
+  );
+}