@fern-api/typescript-dynamic-snippets 0.0.6 → 0.0.8

package/esm/chunk-6Y2IOBCK.js

@@ -1,501 +0,0 @@
-import {
-  Severity
-} from "./chunk-37WY6L3Q.js";
-import {
-  __publicField,
-  assertNever,
-  init_buffer,
-  init_process,
-  typescript_exports
-} from "./chunk-WPDO6IRW.js";
-
-// src/context/DynamicTypeLiteralMapper.ts
-init_process();
-init_buffer();
-var UNION_VALUE_KEY = "value";
-var DynamicTypeLiteralMapper = class {
-  constructor({ context }) {
-    __publicField(this, "context");
-    this.context = context;
-  }
-  convert(args) {
-    if (args.value == null) {
-      return typescript_exports.TypeLiteral.nop();
-    }
-    switch (args.typeReference.type) {
-      case "list":
-        return this.convertList({ list: args.typeReference.value, value: args.value });
-      case "literal":
-        return this.convertLiteral({ literalType: args.typeReference.value, value: args.value });
-      case "map":
-        return this.convertMap({ map: args.typeReference, value: args.value });
-      case "named": {
-        const named = this.context.resolveNamedType({ typeId: args.typeReference.value });
-        if (named == null) {
-          return typescript_exports.TypeLiteral.nop();
-        }
-        return this.convertNamed({ named, value: args.value, as: args.as });
-      }
-      case "optional":
-        return this.convert({ typeReference: args.typeReference.value, value: args.value, as: args.as });
-      case "primitive":
-        return this.convertPrimitive({ primitive: args.typeReference.value, value: args.value, as: args.as });
-      case "set":
-        return this.convertSet({ set: args.typeReference.value, value: args.value });
-      case "unknown":
-        return this.convertUnknown({ value: args.value });
-      default:
-        assertNever(args.typeReference);
-    }
-  }
-  convertLiteral({
-    literalType,
-    value
-  }) {
-    switch (literalType.type) {
-      case "boolean": {
-        const bool = this.context.getValueAsBoolean({ value });
-        if (bool == null) {
-          return typescript_exports.TypeLiteral.nop();
-        }
-        return typescript_exports.TypeLiteral.boolean(bool);
-      }
-      case "string": {
-        const str = this.context.getValueAsString({ value });
-        if (str == null) {
-          return typescript_exports.TypeLiteral.nop();
-        }
-        return typescript_exports.TypeLiteral.string(str);
-      }
-      default:
-        assertNever(literalType);
-    }
-  }
-  convertList({ list, value }) {
-    if (!Array.isArray(value)) {
-      this.context.errors.add({
-        severity: Severity.Critical,
-        message: `Expected array but got: ${typeof value}`
-      });
-      return typescript_exports.TypeLiteral.nop();
-    }
-    return typescript_exports.TypeLiteral.array({
-      values: value.map((v, index) => {
-        this.context.errors.scope({ index });
-        try {
-          return this.convert({ typeReference: list, value: v });
-        } finally {
-          this.context.errors.unscope();
-        }
-      })
-    });
-  }
-  convertSet({ set, value }) {
-    if (!Array.isArray(value)) {
-      this.context.errors.add({
-        severity: Severity.Critical,
-        message: `Expected array but got: ${typeof value}`
-      });
-      return typescript_exports.TypeLiteral.nop();
-    }
-    return typescript_exports.TypeLiteral.set({
-      values: value.map((v, index) => {
-        this.context.errors.scope({ index });
-        try {
-          return this.convert({ typeReference: set, value: v });
-        } finally {
-          this.context.errors.unscope();
-        }
-      })
-    });
-  }
-  convertMap({ map, value }) {
-    if (typeof value !== "object" || value == null) {
-      this.context.errors.add({
-        severity: Severity.Critical,
-        message: `Expected object but got: ${value == null ? "null" : typeof value}`
-      });
-      return typescript_exports.TypeLiteral.nop();
-    }
-    return typescript_exports.TypeLiteral.record({
-      entries: Object.entries(value).map(([key, value2]) => {
-        this.context.errors.scope(key);
-        try {
-          return {
-            key: this.convert({ typeReference: map.key, value: key, as: "key" }),
-            value: this.convert({ typeReference: map.value, value: value2 })
-          };
-        } finally {
-          this.context.errors.unscope();
-        }
-      })
-    });
-  }
-  convertNamed({
-    named,
-    value,
-    as
-  }) {
-    var _a;
-    switch (named.type) {
-      case "alias": {
-        if ((_a = this.context.customConfig) == null ? void 0 : _a.useBrandedStringAliases) {
-          return typescript_exports.TypeLiteral.reference(
-            typescript_exports.codeblock((writer) => {
-              writer.writeNode(
-                typescript_exports.reference({
-                  name: this.context.namespaceExport,
-                  importFrom: this.context.getModuleImport(),
-                  memberName: this.context.getFullyQualifiedReference({
-                    declaration: named.declaration
-                  })
-                })
-              );
-              writer.write("(");
-              writer.writeNode(this.convert({ typeReference: named.typeReference, value, as }));
-              writer.write(")");
-            })
-          );
-        }
-        return this.convert({ typeReference: named.typeReference, value, as });
-      }
-      case "discriminatedUnion":
-        return this.convertDiscriminatedUnion({
-          discriminatedUnion: named,
-          value
-        });
-      case "enum":
-        return this.convertEnum({ enum_: named, value });
-      case "object":
-        return this.convertObject({ object_: named, value });
-      case "undiscriminatedUnion":
-        return this.convertUndicriminatedUnion({ undicriminatedUnion: named, value });
-      default:
-        assertNever(named);
-    }
-  }
-  convertDiscriminatedUnion({
-    discriminatedUnion,
-    value
-  }) {
-    var _a;
-    const discriminatedUnionTypeInstance = this.context.resolveDiscriminatedUnionTypeInstance({
-      discriminatedUnion,
-      value
-    });
-    if (discriminatedUnionTypeInstance == null) {
-      return typescript_exports.TypeLiteral.nop();
-    }
-    const unionVariant = discriminatedUnionTypeInstance.singleDiscriminatedUnionType;
-    const unionProperties = this.convertDiscriminatedUnionProperties({
-      discriminatedUnionTypeInstance,
-      unionVariant
-    });
-    if (unionProperties == null) {
-      return typescript_exports.TypeLiteral.nop();
-    }
-    if ((_a = this.context.customConfig) == null ? void 0 : _a.includeUtilsOnUnionMembers) {
-      return typescript_exports.TypeLiteral.reference(
-        typescript_exports.codeblock((writer) => {
-          writer.writeNode(
-            typescript_exports.invokeMethod({
-              on: typescript_exports.reference({
-                name: this.context.namespaceExport,
-                importFrom: this.context.getModuleImport(),
-                memberName: this.context.getFullyQualifiedReference({
-                  declaration: discriminatedUnion.declaration
-                })
-              }),
-              method: this.context.getMethodName(unionVariant.discriminantValue.name),
-              arguments_: this.convertDiscriminatedUnionUtilsArgs({
-                discriminatedUnionTypeInstance,
-                unionVariant,
-                unionProperties
-              })
-            })
-          );
-        })
-      );
-    }
-    const discriminantProperty = {
-      name: this.context.getPropertyName(discriminatedUnion.discriminant.name),
-      value: typescript_exports.TypeLiteral.string(unionVariant.discriminantValue.wireValue)
-    };
-    return typescript_exports.TypeLiteral.object({
-      fields: [discriminantProperty, ...unionProperties]
-    });
-  }
-  convertDiscriminatedUnionProperties({
-    discriminatedUnionTypeInstance,
-    unionVariant
-  }) {
-    const baseFields = this.getBaseFields({
-      discriminatedUnionTypeInstance,
-      singleDiscriminatedUnionType: unionVariant
-    });
-    switch (unionVariant.type) {
-      case "samePropertiesAsObject": {
-        const named = this.context.resolveNamedType({
-          typeId: unionVariant.typeId
-        });
-        if (named == null) {
-          return void 0;
-        }
-        const converted = this.convertNamed({ named, value: discriminatedUnionTypeInstance.value });
-        if (!converted.isObject()) {
-          this.context.errors.add({
-            severity: Severity.Critical,
-            message: "Internal error; expected union value to be an object"
-          });
-          return void 0;
-        }
-        const object_ = converted.asObjectOrThrow();
-        return [...baseFields, ...object_.fields];
-      }
-      case "singleProperty": {
-        try {
-          this.context.errors.scope(unionVariant.discriminantValue.wireValue);
-          const record = this.context.getRecord(discriminatedUnionTypeInstance.value);
-          if (record == null) {
-            return [
-              ...baseFields,
-              {
-                name: UNION_VALUE_KEY,
-                value: this.convert({
-                  typeReference: unionVariant.typeReference,
-                  value: discriminatedUnionTypeInstance.value
-                })
-              }
-            ];
-          }
-          return [
-            ...baseFields,
-            {
-              name: this.context.getPropertyName(unionVariant.discriminantValue.name),
-              value: this.convert({
-                typeReference: unionVariant.typeReference,
-                value: record[unionVariant.discriminantValue.wireValue]
-              })
-            }
-          ];
-        } finally {
-          this.context.errors.unscope();
-        }
-      }
-      case "noProperties":
-        return baseFields;
-      default:
-        assertNever(unionVariant);
-    }
-  }
-  convertDiscriminatedUnionUtilsArgs({
-    discriminatedUnionTypeInstance,
-    unionVariant,
-    unionProperties
-  }) {
-    if (unionVariant.type === "singleProperty") {
-      const record = this.context.getRecord(discriminatedUnionTypeInstance.value);
-      if (record == null && unionProperties.length === 1) {
-        return [
-          this.convert({
-            typeReference: unionVariant.typeReference,
-            value: discriminatedUnionTypeInstance.value
-          })
-        ];
-      }
-    }
-    return unionProperties.length > 0 ? [typescript_exports.TypeLiteral.object({ fields: unionProperties })] : [];
-  }
-  getBaseFields({
-    discriminatedUnionTypeInstance,
-    singleDiscriminatedUnionType
-  }) {
-    var _a, _b;
-    const properties = this.context.associateByWireValue({
-      parameters: (_a = singleDiscriminatedUnionType.properties) != null ? _a : [],
-      values: (_b = this.context.getRecord(discriminatedUnionTypeInstance.value)) != null ? _b : {},
-      // We're only selecting the base properties here. The rest of the properties
-      // are handled by the union variant.
-      ignoreMissingParameters: true
-    });
-    return properties.map((property) => {
-      this.context.errors.scope(property.name.wireValue);
-      try {
-        return {
-          name: this.context.getPropertyName(property.name.name),
-          value: this.convert(property)
-        };
-      } finally {
-        this.context.errors.unscope();
-      }
-    });
-  }
-  convertObject({ object_, value }) {
-    var _a;
-    const properties = this.context.associateByWireValue({
-      parameters: object_.properties,
-      values: (_a = this.context.getRecord(value)) != null ? _a : {}
-    });
-    return typescript_exports.TypeLiteral.object({
-      fields: properties.map((property) => {
-        this.context.errors.scope(property.name.wireValue);
-        try {
-          return {
-            name: this.context.getPropertyName(property.name.name),
-            value: this.convert(property)
-          };
-        } finally {
-          this.context.errors.unscope();
-        }
-      })
-    });
-  }
-  convertEnum({ enum_, value }) {
-    const enumValue = this.getEnumValue({ enum_, value });
-    if (enumValue == null) {
-      return typescript_exports.TypeLiteral.nop();
-    }
-    return typescript_exports.TypeLiteral.string(enumValue);
-  }
-  getEnumValue({ enum_, value }) {
-    if (typeof value !== "string") {
-      this.context.errors.add({
-        severity: Severity.Critical,
-        message: `Expected enum value string, got: ${typeof value}`
-      });
-      return void 0;
-    }
-    const enumValue = enum_.values.find((v) => v.wireValue === value);
-    if (enumValue == null) {
-      this.context.errors.add({
-        severity: Severity.Critical,
-        message: `An enum value named "${value}" does not exist in this context`
-      });
-      return void 0;
-    }
-    return value;
-  }
-  convertUndicriminatedUnion({
-    undicriminatedUnion,
-    value
-  }) {
-    const result = this.findMatchingUndiscriminatedUnionType({
-      undicriminatedUnion,
-      value
-    });
-    if (result == null) {
-      return typescript_exports.TypeLiteral.nop();
-    }
-    return result;
-  }
-  findMatchingUndiscriminatedUnionType({
-    undicriminatedUnion,
-    value
-  }) {
-    for (const typeReference of undicriminatedUnion.types) {
-      try {
-        return this.convert({ typeReference, value });
-      } catch (e) {
-        continue;
-      }
-    }
-    this.context.errors.add({
-      severity: Severity.Critical,
-      message: `None of the types in the undicriminated union matched the given "${typeof value}" value`
-    });
-    return void 0;
-  }
-  convertUnknown({ value }) {
-    return typescript_exports.TypeLiteral.unknown(value);
-  }
-  convertPrimitive({
-    primitive,
-    value,
-    as
-  }) {
-    var _a, _b;
-    switch (primitive) {
-      case "INTEGER":
-      case "UINT": {
-        const num = this.getValueAsNumber({ value, as });
-        if (num == null) {
-          return typescript_exports.TypeLiteral.nop();
-        }
-        return typescript_exports.TypeLiteral.number(num);
-      }
-      case "LONG":
-      case "UINT_64": {
-        const num = this.getValueAsNumber({ value, as });
-        if (num == null) {
-          return typescript_exports.TypeLiteral.nop();
-        }
-        if ((_a = this.context.customConfig) == null ? void 0 : _a.useBigInt) {
-          return typescript_exports.TypeLiteral.bigint(BigInt(num));
-        }
-        return typescript_exports.TypeLiteral.number(num);
-      }
-      case "FLOAT":
-      case "DOUBLE": {
-        const num = this.getValueAsNumber({ value });
-        if (num == null) {
-          return typescript_exports.TypeLiteral.nop();
-        }
-        return typescript_exports.TypeLiteral.number(num);
-      }
-      case "BOOLEAN": {
-        const bool = this.getValueAsBoolean({ value, as });
-        if (bool == null) {
-          return typescript_exports.TypeLiteral.nop();
-        }
-        return typescript_exports.TypeLiteral.boolean(bool);
-      }
-      case "BASE_64":
-      case "DATE":
-      case "UUID":
-      case "STRING": {
-        const str = this.context.getValueAsString({ value });
-        if (str == null) {
-          return typescript_exports.TypeLiteral.nop();
-        }
-        return typescript_exports.TypeLiteral.string(str);
-      }
-      case "DATE_TIME": {
-        const str = this.context.getValueAsString({ value });
-        if (str == null) {
-          return typescript_exports.TypeLiteral.nop();
-        }
-        return typescript_exports.TypeLiteral.datetime(str);
-      }
-      case "BIG_INTEGER": {
-        const bigInt = this.context.getValueAsString({ value });
-        if (bigInt == null) {
-          return typescript_exports.TypeLiteral.nop();
-        }
-        if ((_b = this.context.customConfig) == null ? void 0 : _b.useBigInt) {
-          return typescript_exports.TypeLiteral.bigint(BigInt(bigInt));
-        }
-        return typescript_exports.TypeLiteral.string(bigInt);
-      }
-      default:
-        assertNever(primitive);
-    }
-  }
-  getValueAsNumber({
-    value,
-    as
-  }) {
-    const num = as === "key" ? typeof value === "string" ? Number(value) : value : value;
-    return this.context.getValueAsNumber({ value: num });
-  }
-  getValueAsBoolean({
-    value,
-    as
-  }) {
-    const bool = as === "key" ? typeof value === "string" ? value === "true" : value === "false" ? false : value : value;
-    return this.context.getValueAsBoolean({ value: bool });
-  }
-};
-
-export {
-  DynamicTypeLiteralMapper
-};