@kinotic-ai/idl 1.0.0-beta.0

package/dist/index.cjs

@@ -0,0 +1,392 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// packages/idl/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  VoidC3Type: () => VoidC3Type,
+  UnionC3Type: () => UnionC3Type,
+  StringC3Type: () => StringC3Type,
+  ShortC3Type: () => ShortC3Type,
+  ServiceDefinition: () => ServiceDefinition,
+  ReferenceC3Type: () => ReferenceC3Type,
+  PropertyDefinition: () => PropertyDefinition,
+  ParameterDefinition: () => ParameterDefinition,
+  ObjectC3Type: () => ObjectC3Type,
+  NotNullDecorator: () => NotNullDecorator,
+  NamespaceDefinition: () => NamespaceDefinition,
+  MapC3Type: () => MapC3Type,
+  LongC3Type: () => LongC3Type,
+  IntC3Type: () => IntC3Type,
+  FunctionDefinition: () => FunctionDefinition,
+  FloatC3Type: () => FloatC3Type,
+  EnumC3Type: () => EnumC3Type,
+  DoubleC3Type: () => DoubleC3Type,
+  DateC3Type: () => DateC3Type,
+  ComplexC3Type: () => ComplexC3Type,
+  CharC3Type: () => CharC3Type,
+  C3Type: () => C3Type,
+  C3Decorator: () => C3Decorator,
+  ByteC3Type: () => ByteC3Type,
+  BooleanC3Type: () => BooleanC3Type,
+  ArrayC3Type: () => ArrayC3Type
+});
+module.exports = __toCommonJS(exports_src);
+
+// packages/idl/src/api/decorators/C3Decorator.ts
+class C3Decorator {
+  type = "";
+}
+// packages/idl/src/api/decorators/NotNullDecorator.ts
+class NotNullDecorator extends C3Decorator {
+  constructor() {
+    super();
+    this.type = "NotNull";
+  }
+}
+// packages/idl/src/api/C3Type.ts
+class C3Type {
+  type = "";
+  constructor(type) {
+    this.type = type;
+  }
+}
+
+// packages/idl/src/api/ArrayC3Type.ts
+class ArrayC3Type extends C3Type {
+  contains;
+  constructor(contains) {
+    super("array");
+    this.contains = contains;
+  }
+}
+// packages/idl/src/api/BooleanC3Type.ts
+class BooleanC3Type extends C3Type {
+  constructor() {
+    super("boolean");
+  }
+}
+// packages/idl/src/api/ByteC3Type.ts
+class ByteC3Type extends C3Type {
+  constructor() {
+    super("byte");
+  }
+}
+// packages/idl/src/api/CharC3Type.ts
+class CharC3Type extends C3Type {
+  constructor() {
+    super("char");
+  }
+}
+// packages/idl/src/api/ComplexC3Type.ts
+class ComplexC3Type extends C3Type {
+  name;
+  namespace;
+  decorators = null;
+  metadata;
+  constructor(type, name, namespace, decorators, metadata) {
+    super(type);
+    this.name = name;
+    this.namespace = namespace;
+    this.decorators = decorators;
+    this.metadata = metadata;
+  }
+  containsDecorator(value) {
+    return this.findDecorator(value) !== null;
+  }
+  hasDecorators() {
+    let ret = false;
+    if (this.decorators) {
+      ret = this.decorators.length > 0;
+    }
+    return ret;
+  }
+  addDecorator(decorator) {
+    if (!this.decorators) {
+      this.decorators = [];
+    } else {
+      if (this.containsDecorator(decorator)) {
+        throw new Error(`C3Base already contains decorator for name ${decorator.type}`);
+      }
+    }
+    this.decorators.push(decorator);
+    return this;
+  }
+  findDecorator(value) {
+    let ret = null;
+    if (this.decorators) {
+      for (const decorator of this.decorators) {
+        if (decorator.type === value.type) {
+          ret = decorator;
+          break;
+        }
+      }
+    }
+    return ret;
+  }
+  getQualifiedName() {
+    return (this.namespace ? this.namespace + "." : "") + this.name;
+  }
+}
+// packages/idl/src/api/DateC3Type.ts
+class DateC3Type extends C3Type {
+  constructor() {
+    super("date");
+  }
+}
+// packages/idl/src/api/DoubleC3Type.ts
+class DoubleC3Type extends C3Type {
+  constructor() {
+    super("double");
+  }
+}
+// packages/idl/src/api/EnumC3Type.ts
+class EnumC3Type extends ComplexC3Type {
+  values = [];
+  constructor(name, namespace, decorators, metadata) {
+    super("enum", name, namespace, decorators, metadata);
+  }
+  addValue(value) {
+    this.values.push(value);
+    return this;
+  }
+}
+// packages/idl/src/api/FloatC3Type.ts
+class FloatC3Type extends C3Type {
+  constructor() {
+    super("float");
+  }
+}
+// packages/idl/src/api/AbstractDefinition.ts
+class AbstractDefinition {
+  name;
+  decorators = null;
+  metadata = null;
+  constructor(name, decorators, metadata) {
+    this.name = name;
+    this.decorators = decorators;
+    this.metadata = metadata;
+  }
+  containsDecorator(value) {
+    return this.findDecorator(value) !== null;
+  }
+  hasDecorators() {
+    let ret = false;
+    if (this.decorators) {
+      ret = this.decorators.length > 0;
+    }
+    return ret;
+  }
+  addDecorator(decorator) {
+    if (!this.decorators) {
+      this.decorators = [];
+    } else {
+      if (this.containsDecorator(decorator)) {
+        throw new Error(`C3Base already contains decorator for name ${decorator.type}`);
+      }
+    }
+    this.decorators.push(decorator);
+  }
+  findDecorator(value) {
+    let ret = null;
+    if (this.decorators) {
+      for (const decorator of this.decorators) {
+        if (decorator.type === value.type) {
+          ret = decorator;
+          break;
+        }
+      }
+    }
+    return ret;
+  }
+}
+
+// packages/idl/src/api/ParameterDefinition.ts
+class ParameterDefinition extends AbstractDefinition {
+  type;
+  constructor(name, type, decorators, metadata) {
+    super(name, decorators, metadata);
+    this.type = type;
+  }
+}
+
+// packages/idl/src/api/VoidC3Type.ts
+class VoidC3Type extends C3Type {
+  constructor() {
+    super("void");
+  }
+}
+
+// packages/idl/src/api/FunctionDefinition.ts
+class FunctionDefinition extends AbstractDefinition {
+  returnType = new VoidC3Type;
+  parameters = [];
+  constructor(name, decorators, metadata) {
+    super(name, decorators, metadata);
+  }
+  addParameter(name, c3Type, decorators) {
+    const param = new ParameterDefinition(name, c3Type, decorators);
+    if (this.parameters.find((value) => value.name === name)) {
+      throw new Error(`FunctionDefinition already contains parameter for name ${name}`);
+    }
+    this.parameters.push(param);
+    return this;
+  }
+}
+// packages/idl/src/api/IntC3Type.ts
+class IntC3Type extends C3Type {
+  constructor() {
+    super("int");
+  }
+}
+// packages/idl/src/api/LongC3Type.ts
+class LongC3Type extends C3Type {
+  constructor() {
+    super("long");
+  }
+}
+// packages/idl/src/api/MapC3Type.ts
+class MapC3Type extends C3Type {
+  key = null;
+  value = null;
+  constructor() {
+    super("map");
+  }
+}
+// packages/idl/src/api/NamespaceDefinition.ts
+class NamespaceDefinition {
+  name = "";
+  complexC3Types = new Set;
+  services = new Set;
+  addComplexC3Types(type) {
+    if (this.complexC3Types.has(type)) {
+      throw new Error(`This NamespaceSchema already contains an ComplexC3Type for name ${type.name}`);
+    }
+    this.complexC3Types.add(type);
+    return this;
+  }
+  addServiceSchema(service) {
+    if (this.services.has(service)) {
+      throw new Error(`This NamespaceSchema already contains an ServiceSchema for name ${service.name}`);
+    }
+    this.services.add(service);
+    return this;
+  }
+}
+// packages/idl/src/api/PropertyDefinition.ts
+class PropertyDefinition extends AbstractDefinition {
+  type;
+  constructor(name, type, decorators, metadata) {
+    super(name, decorators, metadata);
+    this.type = type;
+  }
+}
+
+// packages/idl/src/api/ObjectC3Type.ts
+class ObjectC3Type extends ComplexC3Type {
+  parent = null;
+  properties = [];
+  constructor(name, namespace, decorators, metadata) {
+    super("object", name, namespace, decorators, metadata);
+  }
+  addProperty(name, c3Type, decorators) {
+    return this.addPropertyDefinition(new PropertyDefinition(name, c3Type, decorators));
+  }
+  addPropertyDefinition(propertyDefinition) {
+    this.properties.push(propertyDefinition);
+    return this;
+  }
+  findProperty(name) {
+    let ret = null;
+    if (this.properties) {
+      for (const property of this.properties) {
+        if (property.name === name) {
+          ret = property;
+          break;
+        }
+      }
+    }
+    return ret;
+  }
+}
+// packages/idl/src/api/ReferenceC3Type.ts
+class ReferenceC3Type extends C3Type {
+  qualifiedName = null;
+  constructor() {
+    super("ref");
+  }
+}
+// packages/idl/src/api/ServiceDefinition.ts
+class ServiceDefinition extends AbstractDefinition {
+  namespace;
+  constructor(name, namespace, decorators, metadata) {
+    super(name, decorators, metadata);
+    this.namespace = namespace;
+  }
+  functions = new Set;
+  addFunction(func) {
+    if (this.functions.has(func)) {
+      throw new Error(`ServiceDefinition already contains function for name ${func.name}`);
+    }
+    this.functions.add(func);
+    return this;
+  }
+  getQualifiedName() {
+    return this.namespace + "." + this.name;
+  }
+}
+// packages/idl/src/api/ShortC3Type.ts
+class ShortC3Type extends C3Type {
+  constructor() {
+    super("short");
+  }
+}
+// packages/idl/src/api/StringC3Type.ts
+class StringC3Type extends C3Type {
+  constructor() {
+    super("string");
+  }
+}
+// packages/idl/src/api/UnionC3Type.ts
+class UnionC3Type extends ComplexC3Type {
+  types = [];
+  constructor(name, namespace, decorators, metadata) {
+    super("union", name, namespace, decorators, metadata);
+  }
+}