@code0-tech/definition-reader 0.0.9 → 0.0.10

package/build/index.d.ts

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

package/build/index.js

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

package/build/src/parser.d.ts

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

package/build/src/parser.js

@@ -0,0 +1,50 @@
+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

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

package/build/src/reader.js

@@ -0,0 +1,75 @@
+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

@@ -0,0 +1,17 @@
+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

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

package/package.json

@@ -1,9 +1,15 @@
 {
   "name": "@code0-tech/definition-reader",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "Reader for Code0-Definitions",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./build/index.js",
+      "types": "./build/index.d.ts"
+    }
+  },
   "type": "module",
   "scripts": {
     "build": "tsc"
@@ -20,10 +26,7 @@
     "url": "git+https://github.com/code0-tech/code0-definitions.git"
   },
   "files": [
-    "src",
-    "index.d.ts",
-    "index.js",
-    "package.json"
+    "build"
   ],
   "publishConfig": {
     "access": "public"

package/index.d.ts

@@ -1,20 +0,0 @@
-import {DataType, FlowType, RuntimeFunctionDefinition} from "@code0-tech/sagittarius-graphql-types";
-
-export 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/index.js

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

package/src/parser.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Definition = void 0;
-const reader_1 = require("./reader");
-const index_1 = require("../index");
-const Definition = (rootPath) => {
-    const meta = (0, reader_1.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;
-};
-exports.Definition = Definition;
-function appendMeta(feature, meta) {
-    for (const definition of meta.data) {
-        try {
-            switch (meta.type) {
-                case index_1.MetaType.DataType: {
-                    const parsed = JSON.parse(definition);
-                    feature.dataTypes.push(parsed);
-                    break;
-                }
-                case index_1.MetaType.FlowType: {
-                    const parsed = JSON.parse(definition);
-                    feature.flowTypes.push(parsed);
-                    break;
-                }
-                case index_1.MetaType.RuntimeFunction: {
-                    const parsed = JSON.parse(definition);
-                    feature.runtimeFunctions.push(parsed);
-                    break;
-                }
-            }
-        }
-        catch (err) {
-            console.error(`Error parsing ${meta.type} ${meta.name}:`, err);
-        }
-    }
-}

package/src/parser.ts

@@ -1,54 +0,0 @@
-import {Reader} from './reader';
-import {DataType, FlowType, RuntimeFunctionDefinition} from "@code0-tech/sagittarius-graphql-types";
-import {Feature, Meta, MetaType} from "../index";
-
-export const Definition = (rootPath: string): Feature[] => {
-    const meta = Reader(rootPath);
-    if (!meta) return [];
-    const features: Feature[] = [];
-
-    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: Feature, meta: Meta): void {
-    for (const definition of meta.data) {
-        try {
-            switch (meta.type) {
-                case MetaType.DataType: {
-                    const parsed = JSON.parse(definition) as DataType;
-                    feature.dataTypes.push(parsed);
-                    break;
-                }
-                case MetaType.FlowType: {
-                    const parsed = JSON.parse(definition) as FlowType;
-                    feature.flowTypes.push(parsed);
-                    break;
-                }
-                case MetaType.RuntimeFunction: {
-                    const parsed = JSON.parse(definition) as RuntimeFunctionDefinition;
-                    feature.runtimeFunctions.push(parsed);
-                    break;
-                }
-            }
-        } catch (err: any) {
-            console.error(`Error parsing ${meta.type} ${meta.name}:`, err);
-        }
-    }
-}

package/src/reader.js

@@ -1,126 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Reader = void 0;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const index_1 = require("../index");
-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()) {
-                        const meta = MetaReader(featureName, metaType, defPath);
-                        if (meta)
-                            result.push(meta);
-                    }
-                    else if (def.isDirectory()) {
-                        const subDefinitions = fs.readdirSync(defPath, { withFileTypes: true });
-                        for (const subDef of subDefinitions) {
-                            const subPath = path.join(defPath, subDef.name);
-                            if (!subDef.isFile())
-                                continue;
-                            const meta = MetaReader(featureName, metaType, subPath);
-                            if (meta)
-                                result.push(meta);
-                        }
-                    }
-                }
-            }
-        }
-        return result;
-    }
-    catch (err) {
-        console.error(`Error reading path ${rootPath}:`, err);
-        return [];
-    }
-};
-exports.Reader = Reader;
-const MetaReader = (name, type, filePath) => {
-    let content;
-    try {
-        content = fs.readFileSync(filePath, 'utf-8');
-    }
-    catch (err) {
-        console.error(`Error reading file: ${filePath}`, err);
-        return null;
-    }
-    const lines = content.split('\n');
-    let insideCode = false;
-    const currentBlock = [];
-    const codeSnippets = [];
-    for (const line of lines) {
-        if (line.includes('```')) {
-            insideCode = !insideCode;
-            if (!insideCode) {
-                codeSnippets.push(currentBlock.join(' '));
-                currentBlock.length = 0;
-            }
-            continue;
-        }
-        if (insideCode) {
-            currentBlock.push(line);
-        }
-    }
-    return { name, type, data: codeSnippets };
-};
-function matchMetaType(name) {
-    switch (name) {
-        case 'flow_type':
-            return index_1.MetaType.FlowType;
-        case 'data_type':
-            return index_1.MetaType.DataType;
-        case 'runtime_definition':
-            return index_1.MetaType.RuntimeFunction;
-        default:
-            return null;
-    }
-}

package/src/reader.ts

@@ -1,101 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import {Meta, MetaType} from "../index";
-
-export const Reader = (rootPath: string): Meta[] => {
-    const result: Meta[] = [];
-
-    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()) {
-              const meta = MetaReader(featureName, metaType, defPath);
-              if (meta) result.push(meta);
-            } else if (def.isDirectory()) {
-              const subDefinitions = fs.readdirSync(defPath, { withFileTypes: true });
-
-              for (const subDef of subDefinitions) {
-                const subPath = path.join(defPath, subDef.name);
-                if (!subDef.isFile()) continue;
-
-                const meta = MetaReader(featureName, metaType, subPath);
-                if (meta) result.push(meta);
-              }
-            }
-          }
-        }
-      }
-
-      return result
-    } catch (err) {
-      console.error(`Error reading path ${rootPath}:`, err);
-      return [];
-    }
-}
-
-const MetaReader = (name: string, type: MetaType, filePath: string): Meta | null => {
-    let content: string;
-
-    try {
-      content = fs.readFileSync(filePath, 'utf-8');
-    } catch (err) {
-      console.error(`Error reading file: ${filePath}`, err);
-      return null;
-    }
-
-    const lines = content.split('\n');
-    let insideCode = false;
-    const currentBlock: string[] = [];
-    const codeSnippets: string[] = [];
-
-    for (const line of lines) {
-      if (line.includes('```')) {
-        insideCode = !insideCode;
-
-        if (!insideCode) {
-          codeSnippets.push(currentBlock.join(' '));
-          currentBlock.length = 0;
-        }
-        continue;
-      }
-
-      if (insideCode) {
-        currentBlock.push(line);
-      }
-    }
-
-    return { name, type, data: codeSnippets };
-}
-
-function matchMetaType(name: string): MetaType | null {
-  switch (name) {
-    case 'flow_type':
-      return MetaType.FlowType;
-    case 'data_type':
-      return MetaType.DataType;
-    case 'runtime_definition':
-      return MetaType.RuntimeFunction;
-    default:
-      return null;
-  }
-}