osury 1.1.0 → 1.2.0

package/src/BackendReScript.res.mjs

@@ -1,157 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Core__Array from "@rescript/core/src/Core__Array.res.mjs";
-import * as Core__Option from "@rescript/core/src/Core__Option.res.mjs";
-
-function quoteTag(tag) {
-  let needsQuoting = tag === "" || tag.split("").some(c => {
-    let code = c.charCodeAt(0);
-    return !(code >= 97.0 && code <= 122.0 || code >= 65.0 && code <= 90.0 || code >= 48.0 && code <= 57.0 || code === 95.0);
-  });
-  if (needsQuoting) {
-    return `"` + tag + `"`;
-  } else {
-    return tag;
-  }
-}
-
-function printPrimitive(p) {
-  switch (p) {
-    case "PString" :
-      return "string";
-    case "PFloat" :
-      return "float";
-    case "PInt" :
-      return "int";
-    case "PBool" :
-      return "bool";
-    case "PUnit" :
-      return "unit";
-  }
-}
-
-function printType(t) {
-  if (typeof t !== "object") {
-    return "@s.matches(S.json) JSON.t";
-  }
-  switch (t.TAG) {
-    case "Primitive" :
-      return printPrimitive(t._0);
-    case "Option" :
-      return `option<` + printType(t._0) + `>`;
-    case "Nullable" :
-      return `Nullable.t<` + printType(t._0) + `>`;
-    case "Array" :
-      return `array<` + printType(t._0) + `>`;
-    case "Dict" :
-      return `Dict.t<` + printType(t._0) + `>`;
-    case "Named" :
-      return t._0;
-    case "Enum" :
-      let variants = t._0.map(v => `#` + quoteTag(v)).join(" | ");
-      return `[` + variants + `]`;
-    case "InlineRecord" :
-      return printRecord(t._0);
-    case "InlineVariant" :
-      return printVariantCases(t._0);
-  }
-}
-
-function printField(field) {
-  let typeStr = printType(field.type_);
-  let fieldType = Core__Array.reduce(field.annotations, typeStr, (acc, ann) => {
-    if (typeof ann !== "object" && ann === "SNull") {
-      return `@s.null ` + acc;
-    } else {
-      return acc;
-    }
-  });
-  let asAttr = Core__Option.getOr(Core__Array.findMap(field.annotations, ann => {
-    if (typeof ann !== "object" || ann.TAG !== "As") {
-      return;
-    } else {
-      return `@as("` + ann._0 + `") `;
-    }
-  }), "");
-  return asAttr + field.name + `: ` + fieldType;
-}
-
-function printRecord(fields) {
-  if (fields.length === 0) {
-    return "{}";
-  }
-  let fieldStrs = fields.map(printField);
-  return `{\n  ` + fieldStrs.join(",\n  ") + `\n}`;
-}
-
-function printVariantCase(c) {
-  let payloadStr = printType(c.payload);
-  return c.tag + `(` + payloadStr + `)`;
-}
-
-function printVariantCases(cases) {
-  let caseStrs = cases.map(printVariantCase);
-  return `[` + caseStrs.map(c => `#` + quoteTag(c)).join(" | ") + `]`;
-}
-
-function printAnnotation(ann) {
-  if (typeof ann === "object") {
-    if (ann.TAG === "Tag") {
-      return `@tag("` + ann._0 + `")`;
-    } else {
-      return;
-    }
-  }
-  switch (ann) {
-    case "GenType" :
-      return "@genType";
-    case "Schema" :
-      return "@schema";
-    case "Unboxed" :
-      return "@unboxed";
-    case "SNull" :
-      return;
-  }
-}
-
-function printAnnotations(annotations) {
-  return Core__Array.filterMap(annotations, printAnnotation).join("\n");
-}
-
-function printTypeDef(typeDef) {
-  let annotations = printAnnotations(typeDef.annotations);
-  let fields = typeDef.kind;
-  let body;
-  switch (fields.TAG) {
-    case "RecordDef" :
-      body = printRecord(fields._0);
-      break;
-    case "VariantDef" :
-      body = fields._0.map(printVariantCase).join(" | ");
-      break;
-    case "AliasDef" :
-      body = printType(fields._0);
-      break;
-  }
-  return annotations + `\ntype ` + typeDef.name + ` = ` + body;
-}
-
-function print(module_) {
-  let typeDefs = module_.types.map(printTypeDef).join("\n\n");
-  return module_.preamble + "\n\n" + typeDefs;
-}
-
-export {
-  quoteTag,
-  printPrimitive,
-  printType,
-  printField,
-  printRecord,
-  printVariantCase,
-  printVariantCases,
-  printAnnotation,
-  printAnnotations,
-  printTypeDef,
-  print,
-}
-/* No side effect */

package/src/Codegen.res.mjs

@@ -1,160 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as IRGen from "./IRGen.res.mjs";
-import * as Errors from "./Errors.res.mjs";
-import * as CodegenShims from "./CodegenShims.res.mjs";
-import * as CodegenTypes from "./CodegenTypes.res.mjs";
-import * as CodegenHelpers from "./CodegenHelpers.res.mjs";
-import * as BackendReScript from "./BackendReScript.res.mjs";
-import * as CodegenTransforms from "./CodegenTransforms.res.mjs";
-
-function generateModuleWithDiagnostics(schemas) {
-  let irModule = IRGen.generate(schemas);
-  if (irModule.TAG !== "Ok") {
-    return {
-      TAG: "Error",
-      _0: irModule._0
-    };
-  }
-  let irModule$1 = irModule._0;
-  let code = BackendReScript.print(irModule$1);
-  return {
-    TAG: "Ok",
-    _0: {
-      code: code,
-      warnings: irModule$1.warnings
-    }
-  };
-}
-
-function generateModule(schemas) {
-  let result = generateModuleWithDiagnostics(schemas);
-  if (result.TAG === "Ok") {
-    let result$1 = result._0;
-    result$1.warnings.forEach(w => {
-      console.log(w);
-    });
-    return result$1.code;
-  }
-  result._0.forEach(e => {
-    console.error(Errors.formatError(e));
-  });
-  return "";
-}
-
-let lcFirst = CodegenHelpers.lcFirst;
-
-let ucFirst = CodegenHelpers.ucFirst;
-
-let reservedKeywords = CodegenHelpers.reservedKeywords;
-
-let isReservedKeyword = CodegenHelpers.isReservedKeyword;
-
-let isOptionalType = CodegenHelpers.isOptionalType;
-
-let isNullableType = CodegenHelpers.isNullableType;
-
-let getTagForType = CodegenHelpers.getTagForType;
-
-let hasUnion = CodegenHelpers.hasUnion;
-
-let isPrimitiveOnlyUnion = CodegenHelpers.isPrimitiveOnlyUnion;
-
-let collectInlineEnums = CodegenTransforms.collectInlineEnums;
-
-let resolveEnumNames = CodegenTransforms.resolveEnumNames;
-
-let camelize = CodegenTransforms.camelize;
-
-let replaceInlineEnums = CodegenTransforms.replaceInlineEnums;
-
-let buildExtractedEnumSchemas = CodegenTransforms.buildExtractedEnumSchemas;
-
-let isRefPlusDictUnion = CodegenTransforms.isRefPlusDictUnion;
-
-let isPrimitivePlusDictUnion = CodegenTransforms.isPrimitivePlusDictUnion;
-
-let getUnionName = CodegenTransforms.getUnionName;
-
-let getPolyVariantName = CodegenTransforms.getPolyVariantName;
-
-let extractUnions = CodegenTransforms.extractUnions;
-
-let extractUnionsFromType = CodegenTransforms.extractUnionsFromType;
-
-let replaceUnions = CodegenTransforms.replaceUnions;
-
-let replaceUnionInType = CodegenTransforms.replaceUnionInType;
-
-let getDependencies = CodegenTransforms.getDependencies;
-
-let topologicalSort = CodegenTransforms.topologicalSort;
-
-let buildSkipSchemaSet = CodegenTransforms.buildSkipSchemaSet;
-
-let collectUnionWarnings = CodegenTransforms.collectUnionWarnings;
-
-let validateUnionDiscriminators = CodegenTransforms.validateUnionDiscriminators;
-
-let generateType = CodegenTypes.generateType;
-
-let generateTypeDef = CodegenTypes.generateTypeDef;
-
-let generateTypeDefWithSkipSet = CodegenTypes.generateTypeDefWithSkipSet;
-
-let generateVariantBody = CodegenTypes.generateVariantBody;
-
-let generateInlineVariantBody = CodegenTypes.generateInlineVariantBody;
-
-let generateInlineRecord = CodegenTypes.generateInlineRecord;
-
-let generateDictShim = CodegenShims.generateDictShim;
-
-let generateJsonShim = CodegenShims.generateJsonShim;
-
-let generateNullableShim = CodegenShims.generateNullableShim;
-
-let generateNullableModule = CodegenShims.generateNullableModule;
-
-export {
-  lcFirst,
-  ucFirst,
-  reservedKeywords,
-  isReservedKeyword,
-  isOptionalType,
-  isNullableType,
-  getTagForType,
-  hasUnion,
-  isPrimitiveOnlyUnion,
-  collectInlineEnums,
-  resolveEnumNames,
-  camelize,
-  replaceInlineEnums,
-  buildExtractedEnumSchemas,
-  isRefPlusDictUnion,
-  isPrimitivePlusDictUnion,
-  getUnionName,
-  getPolyVariantName,
-  extractUnions,
-  extractUnionsFromType,
-  replaceUnions,
-  replaceUnionInType,
-  getDependencies,
-  topologicalSort,
-  buildSkipSchemaSet,
-  collectUnionWarnings,
-  validateUnionDiscriminators,
-  generateType,
-  generateTypeDef,
-  generateTypeDefWithSkipSet,
-  generateVariantBody,
-  generateInlineVariantBody,
-  generateInlineRecord,
-  generateDictShim,
-  generateJsonShim,
-  generateNullableShim,
-  generateNullableModule,
-  generateModuleWithDiagnostics,
-  generateModule,
-}
-/* No side effect */

package/src/CodegenHelpers.res.mjs

@@ -1,233 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-
-let reservedKeywords = [
-  "type",
-  "let",
-  "rec",
-  "and",
-  "as",
-  "open",
-  "include",
-  "module",
-  "sig",
-  "struct",
-  "exception",
-  "external",
-  "if",
-  "else",
-  "switch",
-  "while",
-  "for",
-  "try",
-  "catch",
-  "when",
-  "true",
-  "false",
-  "assert",
-  "lazy",
-  "constraint",
-  "functor",
-  "class",
-  "method",
-  "object",
-  "private",
-  "public",
-  "virtual",
-  "mutable",
-  "new",
-  "inherit",
-  "initializer",
-  "val",
-  "with",
-  "match",
-  "of",
-  "fun",
-  "function",
-  "in",
-  "do",
-  "done",
-  "begin",
-  "end",
-  "then",
-  "to",
-  "downto",
-  "or",
-  "land",
-  "lor",
-  "lxor",
-  "lsl",
-  "lsr",
-  "asr",
-  "mod",
-  "await",
-  "async"
-];
-
-function isReservedKeyword(name) {
-  return reservedKeywords.includes(name);
-}
-
-function lcFirst(s) {
-  if (s.length === 0) {
-    return s;
-  }
-  let first = s.charAt(0).toLowerCase();
-  let rest = s.slice(1);
-  return first + rest;
-}
-
-function ucFirst(s) {
-  if (s.length === 0) {
-    return s;
-  }
-  let first = s.charAt(0).toUpperCase();
-  let rest = s.slice(1);
-  return first + rest;
-}
-
-function isOptionalType(schema) {
-  if (typeof schema !== "object") {
-    return false;
-  }
-  switch (schema._tag) {
-    case "Optional" :
-    case "Nullable" :
-      return true;
-    default:
-      return false;
-  }
-}
-
-function isNullableType(schema) {
-  if (typeof schema !== "object") {
-    return false;
-  } else {
-    return schema._tag === "Nullable";
-  }
-}
-
-function getTagForType(t) {
-  if (typeof t !== "object") {
-    switch (t) {
-      case "String" :
-        return "String";
-      case "Number" :
-        return "Float";
-      case "Integer" :
-        return "Int";
-      case "Boolean" :
-        return "Bool";
-      case "Null" :
-        return "Null";
-      case "Unknown" :
-        return "Unknown";
-    }
-  } else {
-    switch (t._tag) {
-      case "Optional" :
-        return `Option` + getTagForType(t._0);
-      case "Nullable" :
-        return `Null` + getTagForType(t._0);
-      case "Object" :
-        return "Object";
-      case "Array" :
-        return `Array` + getTagForType(t._0);
-      case "Ref" :
-        return ucFirst(t._0);
-      case "Enum" :
-        return "Enum";
-      case "PolyVariant" :
-        return "Variant";
-      case "Dict" :
-        return "Dict";
-      case "Union" :
-        return "Union";
-    }
-  }
-}
-
-function hasUnion(_schema) {
-  while (true) {
-    let schema = _schema;
-    if (typeof schema !== "object") {
-      return false;
-    }
-    switch (schema._tag) {
-      case "Object" :
-        return schema._0.some(f => hasUnion(f.type));
-      case "PolyVariant" :
-        return schema._0.some(c => hasUnion(c.payload));
-      case "Optional" :
-      case "Nullable" :
-      case "Array" :
-      case "Dict" :
-        _schema = schema._0;
-        continue;
-      case "Union" :
-        return true;
-      default:
-        return false;
-    }
-  };
-}
-
-function hasUnknown(_schema) {
-  while (true) {
-    let schema = _schema;
-    if (typeof schema !== "object") {
-      return schema === "Unknown";
-    }
-    switch (schema._tag) {
-      case "Object" :
-        return schema._0.some(f => hasUnknown(f.type));
-      case "PolyVariant" :
-        return schema._0.some(c => hasUnknown(c.payload));
-      case "Optional" :
-      case "Nullable" :
-      case "Array" :
-      case "Dict" :
-        _schema = schema._0;
-        continue;
-      default:
-        return false;
-    }
-  };
-}
-
-function isPrimitiveOnlyUnion(types) {
-  let allPrimitive = types.every(t => {
-    if (typeof t === "object") {
-      return false;
-    }
-    switch (t) {
-      case "String" :
-      case "Number" :
-      case "Integer" :
-      case "Boolean" :
-        return true;
-      default:
-        return false;
-    }
-  });
-  if (!allPrimitive) {
-    return false;
-  }
-  let hasFloat = types.some(t => t === "Number");
-  let hasInt = types.some(t => t === "Integer");
-  return !(hasFloat && hasInt);
-}
-
-export {
-  reservedKeywords,
-  isReservedKeyword,
-  lcFirst,
-  ucFirst,
-  isOptionalType,
-  isNullableType,
-  getTagForType,
-  hasUnion,
-  hasUnknown,
-  isPrimitiveOnlyUnion,
-}
-/* No side effect */

package/src/CodegenShims.res.mjs

@@ -1,44 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-
-function generateDictShim() {
-  return `// Generated by osury - Dict type shim for @genType
-export type t<T> = { [key: string]: T };
-`;
-}
-
-function generateNullableShim() {
-  return `/**
- * Type shim for ReScript Nullable.t
- *
- * This file is generated by osury (not by ReScript/genType).
- * It maps ReScript's option<T> to TypeScript's T | null for JSON nullable fields.
- *
- * ReScript side: Nullable.t<T> = option<T> (works with sury's S.null schema)
- * TypeScript side: t<T> = T | null (correct JSON null representation)
- */
-export type t<T> = T | null;
-`;
-}
-
-function generateJsonShim() {
-  return `// Generated by osury - JSON type shim for @genType
-export type t = unknown;
-`;
-}
-
-function generateNullableModule() {
-  return `// Generated by osury - Nullable type for JSON null values
-// This is option<T> internally but maps to T | null in TypeScript via shim
-@genType.import(("./Nullable.shim.ts", "t"))
-type t<'a> = option<'a>
-`;
-}
-
-export {
-  generateDictShim,
-  generateNullableShim,
-  generateJsonShim,
-  generateNullableModule,
-}
-/* No side effect */