2.0.1 • Published 1 month ago

@himenon/path-oriented-data-structure

Licence

MIT

Version

2.0.1

Deps

Size

82 kB

Vulns

Weekly

Summary Dependency Versions

@himenon/path-oriented-data-structure

Data structure management library that extends Composite Pattern to Path orientation.

Usage

Basic Usage

import { Operator, Node } from "@himenon/path-oriented-data-structure";

const operator = new Operator("tree");

const NODE_KIND_A = "node_a" as const;
const NODE_KIND_B = "node_b" as const;

operator.set("a", new Node(NODE_KIND_A, "node_a1"));
operator.set("a/b", new Node(NODE_KIND_A, "node_a2"));
operator.set("a/b/c", new Node(NODE_KIND_A, "node_A3"));

operator.set("a", new Node(NODE_KIND_B, "node_b1"));
operator.set("a/b", new Node(NODE_KIND_B, "node_b2"));
operator.set("a/b/c", new Node(NODE_KIND_B, "node_b3"));

operator.getHierarchy(); // Results below

Result: operator.getHierarchy()


__CODE_BLOCK_1__

Extended usage of `Node`

import { Operator, Node } from "@himenon/path-oriented-data-structure";

export type KindOfString = "string";
export type KindOfNumber = "number";
export type Kind = KindOfNumber | KindOfString;

export class StringValueNode extends Node<KindOfString> {
  constructor(
    name: string,
    private value: string,
  ) {
    super("string", name);
  }
  public getValue(): string {
    return this.value;
  }
  public setValue(value: string): void {
    this.value = value;
  }
}

export class NumberValueNode extends Node<KindOfNumber> {
  constructor(
    name: string,
    private value: number,
  ) {
    super("number", name);
  }
  public getValue(): number {
    return this.value;
  }
}

export type GetNode<T extends Kind> = T extends KindOfString ? StringValueNode : T extends KindOfNumber ? NumberValueNode : never;

// Type Safe method
export const createGetChildByPaths =
  (operator: Operator<string>) =>
  <T extends Kind>(path: string, kind: T): GetNode<T> | undefined => {
    return operator.getChildByPaths(path, kind) as GetNode<T> | undefined;
  };

const operator = new Operator("tree");

operator.set("a/b", new StringValueNode("stringValue", "hello world"));
operator.set("a/b", new NumberValueNode("numberValue", 123455));

operator.getHierarchy(); // Results below

const getChildByPaths = createGetChildByPaths(operator);

getChildByPaths("a/b", "string"); // ReturnType: StringValueNode | undefined
getChildByPaths("a/b", "number"); // ReturnType: NumberValueNode | undefined