@code0-tech/definition-reader 0.0.13 → 0.0.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@code0-tech/definition-reader",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "Reader for Code0-Definitions",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -12,14 +12,14 @@
   },
   "type": "module",
   "scripts": {
-    "build": "tsc"
+    "build": "npx vite build && node dist/definition-reader.js"
   },
   "author": "",
   "license": "",
   "devDependencies": {
-    "@code0-tech/sagittarius-graphql-types": "^0.0.0-4b2e73eae302fe499001bf42fdb3a6bcc5be78aa ",
     "@types/node": "^24.1.0",
-    "typescript": "^5.8.3"
+    "typescript": "^5.8.3",
+    "vite": "^7.1.11"
   },
   "repository": {
     "type": "git",
@@ -30,5 +30,10 @@
   ],
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@code0-tech/sagittarius-graphql-types": "^0.0.0-00f33663039d78ad59e95306730878c687de5c48",
+    "@code0-tech/tucana": "^0.0.37",
+    "@protobuf-ts/runtime": "^2.11.1"
   }
 }

package/build/index.d.ts

@@ -1,2 +0,0 @@
-export { Definition } from './src/parser.js';
-export type { Feature, MetaType, Meta } from './src/types.js';

package/build/index.js

@@ -1 +0,0 @@
-export { Definition } from './src/parser.js';

package/build/src/parser.d.ts

@@ -1,2 +0,0 @@
-import { Feature } from "./types.js";
-export declare const Definition: (rootPath: string) => Feature[];

package/build/src/parser.js

@@ -1,50 +0,0 @@
-import { Reader } from './reader.js';
-import { MetaType } from "./types.js";
-export const Definition = (rootPath) => {
-    const meta = Reader(rootPath);
-    if (!meta)
-        return [];
-    const features = [];
-    for (const m of meta) {
-        let feature = features.find((f) => f.name === m.name);
-        if (feature) {
-            appendMeta(feature, m);
-        }
-        else {
-            feature = {
-                name: m.name,
-                dataTypes: [],
-                flowTypes: [],
-                runtimeFunctions: [],
-            };
-            appendMeta(feature, m);
-            features.push(feature);
-        }
-    }
-    return features;
-};
-function appendMeta(feature, meta) {
-    const definition = meta.data;
-    try {
-        switch (meta.type) {
-            case MetaType.DataType: {
-                const parsed = JSON.parse(definition);
-                feature.dataTypes.push(parsed);
-                break;
-            }
-            case MetaType.FlowType: {
-                const parsed = JSON.parse(definition);
-                feature.flowTypes.push(parsed);
-                break;
-            }
-            case MetaType.RuntimeFunction: {
-                const parsed = JSON.parse(definition);
-                feature.runtimeFunctions.push(parsed);
-                break;
-            }
-        }
-    }
-    catch (err) {
-        console.error(`Error parsing ${meta.type} ${meta.name} ${definition}:`, err);
-    }
-}

package/build/src/reader.d.ts

@@ -1,2 +0,0 @@
-import { Meta } from "./types.js";
-export declare const Reader: (rootPath: string) => Meta[];

package/build/src/reader.js

@@ -1,75 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { MetaType } from "./types.js";
-export const Reader = (rootPath) => {
-    const result = [];
-    try {
-        const features = fs.readdirSync(rootPath, { withFileTypes: true });
-        for (const featureDirent of features) {
-            if (!featureDirent.isDirectory())
-                continue;
-            const featurePath = path.join(rootPath, featureDirent.name);
-            const featureName = featureDirent.name;
-            const typeDirs = fs.readdirSync(featurePath, { withFileTypes: true });
-            for (const typeDirent of typeDirs) {
-                if (!typeDirent.isDirectory())
-                    continue;
-                const metaType = matchMetaType(typeDirent.name);
-                if (!metaType)
-                    continue;
-                const typePath = path.join(featurePath, typeDirent.name);
-                const definitions = fs.readdirSync(typePath, { withFileTypes: true });
-                for (const def of definitions) {
-                    const defPath = path.join(typePath, def.name);
-                    if (def.isFile()) {
-                        if (!defPath.endsWith('.json'))
-                            continue;
-                        try {
-                            const content = fs.readFileSync(defPath, 'utf-8');
-                            const meta = { name: featureName, type: metaType, data: content };
-                            result.push(meta);
-                        }
-                        catch (err) {
-                            console.error(`Error reading file: ${defPath}`, err);
-                        }
-                    }
-                    else if (def.isDirectory()) {
-                        const subDefinitions = fs.readdirSync(defPath, { withFileTypes: true });
-                        for (const subDef of subDefinitions) {
-                            const subPath = path.join(defPath, subDef.name);
-                            if (!subPath.endsWith('.json'))
-                                continue;
-                            if (!subDef.isFile())
-                                continue;
-                            try {
-                                const content = fs.readFileSync(subPath, 'utf-8');
-                                const meta = { name: featureName, type: metaType, data: content };
-                                result.push(meta);
-                            }
-                            catch (err) {
-                                console.error(`Error reading file: ${subPath}`, err);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return result;
-    }
-    catch (err) {
-        console.error(`Error reading path ${rootPath}:`, err);
-        return [];
-    }
-};
-function matchMetaType(name) {
-    switch (name) {
-        case 'flow_type':
-            return MetaType.FlowType;
-        case 'data_type':
-            return MetaType.DataType;
-        case 'runtime_definition':
-            return MetaType.RuntimeFunction;
-        default:
-            return null;
-    }
-}

package/build/src/types.d.ts

@@ -1,17 +0,0 @@
-import { DataType, FlowType, RuntimeFunctionDefinition } from "@code0-tech/sagittarius-graphql-types";
-export declare enum MetaType {
-    FlowType = "FlowType",
-    DataType = "DataType",
-    RuntimeFunction = "RuntimeFunction"
-}
-export interface Meta {
-    name: string;
-    type: MetaType;
-    data: string;
-}
-export interface Feature {
-    name: string;
-    dataTypes: DataType[];
-    flowTypes: FlowType[];
-    runtimeFunctions: RuntimeFunctionDefinition[];
-}

package/build/src/types.js

@@ -1,6 +0,0 @@
-export var MetaType;
-(function (MetaType) {
-    MetaType["FlowType"] = "FlowType";
-    MetaType["DataType"] = "DataType";
-    MetaType["RuntimeFunction"] = "RuntimeFunction";
-})(MetaType || (MetaType = {}));