@garrix82/reactgenie-dsl 1.0.3 → 1.0.5

package/README.md

@@ -136,12 +136,18 @@ export class Counter extends DataClass {
 
   static Examples = [
     {
-      user_utterance: "increment the apples counter",
-      example_parsed: 'Counter.findByName(name: "apples").increment()',
+      userUtterance: {
+        en: "increment the apples counter",
+        de: "erhoehe den apples Zaehler",
+      },
+      exampleParsed: 'Counter.findByName(name: "apples").increment()',
     },
     {
-      user_utterance: "what is the apples count",
-      example_parsed: 'Counter.findByName(name: "apples").count',
+      userUtterance: {
+        en: "what is the apples count",
+        de: "wie ist der apples Zaehlerstand",
+      },
+      exampleParsed: 'Counter.findByName(name: "apples").count',
     },
   ];
 
@@ -224,11 +230,11 @@ const descriptors = Object.values(AllGenieObjects).map(
 
 const examples: ExampleParse[] = [
   new ExampleParse(
-    "increment the apples counter",
+    { en: "increment the apples counter", de: "erhoehe den apples Zaehler" },
     'Counter.findByName(name: "apples").increment()'
   ),
   new ExampleParse(
-    "what is the apples count",
+    { en: "what is the apples count", de: "wie ist der apples Zaehlerstand" },
     'Counter.findByName(name: "apples").count'
   ),
 ];

package/dist/cli/dsl-interpreter.d.ts

@@ -0,0 +1,92 @@
+import { ClassDescriptor, GenieObject } from "../dsl-descriptor";
+export declare class InterpreterError extends Error {
+}
+export declare class ClassMissingError extends InterpreterError {
+    class_name: string;
+    constructor(class_name: string);
+}
+export declare class FieldMissingError extends InterpreterError {
+    class_name: string;
+    field_name: string;
+    constructor(class_name: string, field_name: string);
+}
+export declare class FieldStaticError extends InterpreterError {
+    class_name: string;
+    field_name: string;
+    constructor(class_name: string, field_name: string);
+}
+export declare class FunctionMissingError extends InterpreterError {
+    class_name: string;
+    func_name: string;
+    constructor(class_name: string, func_name: string);
+}
+export declare class FunctionStaticError extends InterpreterError {
+    class_name: string;
+    func_name: string;
+    constructor(class_name: string, func_name: string);
+}
+export declare class InvalidParameterTypeError extends InterpreterError {
+    func_name: string;
+    parameter_name: string;
+    expected_type: string;
+    received_type: string;
+    constructor(func_name: string, parameter_name: string, expected_type: string, received_type: string);
+}
+export type DslTraceEntry = {
+    sequence: number;
+    primitive: string;
+    fieldAccessor?: string;
+    candidate?: any;
+    fieldValue?: any;
+    comparison?: any;
+    matched?: boolean;
+    reason: string;
+};
+export type DslInterpreterOptions = {
+    onTrace?: (entry: DslTraceEntry) => void;
+};
+export declare class DslInterpreter {
+    dry_run: boolean;
+    private options;
+    private traceSequence;
+    private matching;
+    private contains;
+    private equals;
+    private compareObjectsSafely;
+    private isDateOnlyString;
+    private isIsoDateTimeString;
+    private normalizeBetweenBound;
+    private arrayFunctionDescriptors;
+    private emitTrace;
+    private serializeAccessor;
+    private serializeCandidate;
+    private serializeValue;
+    private explainMatching;
+    private explainContains;
+    private explainEquals;
+    private explainBetween;
+    private arrayFunctionImplementations;
+    resolveSteps: any[];
+    resolveStepsEnabled: boolean;
+    classDescriptors: ClassDescriptor<GenieObject>[];
+    constructor(classDescriptors: ClassDescriptor<GenieObject>[], dry_run?: boolean, options?: DslInterpreterOptions);
+    interpret(input: string): Promise<any>;
+    interpretSteps(input: string): Promise<{
+        ast: any;
+        result: any;
+        steps: {
+            ast: any;
+            result: any;
+        }[];
+    }[]>;
+    describe(ast: any): Promise<any>;
+    describeSteps(list: any[]): Promise<any[]>;
+    strip(ast: any): any;
+    resolve(ast: any, env?: null | any): Promise<any>;
+    private describeResolvedParameterType;
+    private validateResolvedParameters;
+    private resolveAccess;
+    private resolveIndex;
+    private resolveArray;
+    private resolveFunctionCall;
+}