docs: added package usage to readme

Author: raphael-goetz

README.md

@@ -1,33 +1,55 @@
-# Definition CLI
+# Definitions
 
-## Setup
-```bash
-cargo build --release
-```
+## Definition CLI
 
-## Usage
+### Setup
+[Install Cargo](https://doc.rust-lang.org/cargo/getting-started/installation.html)
 
+### Usage
+(Stay inside the root directory when running the command)
 ### General Report
 ```bash
-./cli report
-./cli report -p /path/to/definitions
+./cargo run report
+./cargo run report -p /path/to/definitions
 ```
 
 ### Feature Report
 ```bash
-./cli feature
-./cli feature -f feature_name
-./cli feature -f feature_name -p /path/to/definitions
+./cargo run feature
+./cargo run feature -p /path/to/definitions
+./cargo run feature -f feature_name
+./cargo run feature -f feature_name -p /path/to/definitions
 ```
 
 ### Watch for Changes
 ```bash
-./cli watch
-./cli watch -p /path/to/definitions
+./cargo run watch
+./cargo run watch -p /path/to/definitions
 ```
 
 ### Definition
 ```bash
-./cli definition -n definition_name
-./cli definition -n definition_name -p /path/to/definitions
+./cargo run definition -n definition_name
+./cargo run definition -n definition_name -p /path/to/definitions
+```
+
+## TypeScript Definition Package
+
+### Install Package
+```bash
+npm i @code0-tech/code0-definition-reader --save-dev
 ```
+
+### Usage
+
+```ts
+const features = Definition("./path/to/definitions")
+
+for (const feature in features) {
+    const name = feature.name; //name of the feature (e.g. rest)
+    const dataTypes = fearture.dataTypes; //dataTypes of this feature
+    const flowTypes = fearture.flowTypes; //flowTypes of this feature
+    const functions = fearture.runtimeFunctions; //runtimeFunctions of this feature
+}
+```
+

reader/ts/src/parser.ts

@@ -3,9 +3,9 @@ import {DataType, FlowType, RuntimeFunctionDefinition} from "@code0-tech/sagitta
 
 export interface Feature {
     name: string;
-    data_types: DataType[];
-    flow_types: FlowType[];
-    runtime_functions: RuntimeFunctionDefinition[];
+    dataTypes: DataType[];
+    flowTypes: FlowType[];
+    runtimeFunctions: RuntimeFunctionDefinition[];
 }
 
 export const Definition = (rootPath: string): Feature[] => {
@@ -21,9 +21,9 @@ export const Definition = (rootPath: string): Feature[] => {
         } else {
             feature = {
                 name: m.name,
-                data_types: [],
-                flow_types: [],
-                runtime_functions: [],
+                dataTypes: [],
+                flowTypes: [],
+                runtimeFunctions: [],
             };
             appendMeta(feature, m);
             features.push(feature);
@@ -39,17 +39,17 @@ function appendMeta(feature: Feature, meta: Meta): void {
             switch (meta.type) {
                 case MetaType.DataType: {
                     const parsed = JSON.parse(definition) as DataType;
-                    feature.data_types.push(parsed);
+                    feature.dataTypes.push(parsed);
                     break;
                 }
                 case MetaType.FlowType: {
                     const parsed = JSON.parse(definition) as FlowType;
-                    feature.flow_types.push(parsed);
+                    feature.flowTypes.push(parsed);
                     break;
                 }
                 case MetaType.RuntimeFunction: {
                     const parsed = JSON.parse(definition) as RuntimeFunctionDefinition;
-                    feature.runtime_functions.push(parsed);
+                    feature.runtimeFunctions.push(parsed);
                     break;
                 }
             }