https://github.com/himenon/path-oriented-data-structure
A composite pattern with a Path-oriented data structure.
https://github.com/himenon/path-oriented-data-structure
composite-pattern data-structure path-oriented typescript
Last synced: 10 months ago
JSON representation
A composite pattern with a Path-oriented data structure.
- Host: GitHub
- URL: https://github.com/himenon/path-oriented-data-structure
- Owner: Himenon
- License: mit
- Created: 2021-01-15T14:48:48.000Z (about 5 years ago)
- Default Branch: main
- Last Pushed: 2024-02-04T12:38:37.000Z (about 2 years ago)
- Last Synced: 2025-03-17T04:04:55.931Z (11 months ago)
- Topics: composite-pattern, data-structure, path-oriented, typescript
- Language: TypeScript
- Homepage: https://npmjs.com/package/@himenon/path-oriented-data-structure
- Size: 483 KB
- Stars: 0
- Watchers: 1
- Forks: 1
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Contributing: CONTRIBUTING.md
- License: LICENSE
Awesome Lists containing this project
README
# @himenon/path-oriented-data-structure
Data structure management library that extends Composite Pattern to Path orientation.
## Usage
### Basic Usage
```ts
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()
{
"name": ".",
"children": {
"node_a:a": {
"name": "node_a1"
},
"tree:a": {
"name": "a",
"children": {
"node_a:b": {
"name": "node_a2"
},
"tree:b": {
"name": "b",
"children": {
"node_a:c": {
"name": "node_A3"
},
"node_b:c": {
"name": "node_b3"
}
}
},
"node_b:b": {
"name": "node_b2"
}
}
},
"node_b:a": {
"name": "node_b1"
}
}
}
### Extended usage of `Node`
```ts
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 {
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 {
constructor(name: string, private value: number) {
super("number", name);
}
public getValue(): number {
return this.value;
}
}
export type GetNode = T extends KindOfString ? StringValueNode : T extends KindOfNumber ? NumberValueNode : never;
// Type Safe method
export const createGetChildByPaths = (operator: Operator) => (path: string, kind: T): GetNode | undefined => {
return operator.getChildByPaths(path, kind) as GetNode | 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
```
Result: operator.getHierarchy()
{
"name": ".",
"children": {
"tree:a": {
"name": "a",
"children": {
"string:b": {
"name": "stringValue"
},
"number:b": {
"name": "numberValue"
}
}
}
}
}
## API
### `Operator`
#### `getChildByPaths(path: string, kind: string): Component | undefined`
#### `set(path: string, component: Component): void`
#### `remove(path: string, kind: string): void`
#### `copy(from: string, to: string, kind: string): boolean`
#### `move(from: string, to: string, kind: string): boolean`
#### `getChildPaths(kind: string): string[]`
## LICENCE
[@himenon/path-oriented-data-structure](https://github.com/Himenon/path-oriented-data-structure)・MIT