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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fern-api/typescript-dynamic-snippets",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "repository": {
     "type": "git",
     "url": "https://github.com/fern-api/fern.git",
@@ -24,4 +24,4 @@
     "cjs",
     "esm"
   ]
-}
+}

package/esm/chunk-37WY6L3Q.js

@@ -1,551 +0,0 @@
-import {
-  __objRest,
-  __publicField,
-  __restKey,
-  __spreadProps,
-  __spreadValues,
-  assertNever,
-  init_buffer,
-  init_process,
-  keys
-} from "./chunk-WPDO6IRW.js";
-
-// ../../browser-compatible-base/lib/dynamic-snippets/AbstractDynamicSnippetsGenerator.js
-init_process();
-init_buffer();
-var AbstractDynamicSnippetsGenerator = class {
-  constructor(context) {
-    __publicField(this, "context");
-    this.context = context;
-  }
-};
-
-// ../../browser-compatible-base/lib/dynamic-snippets/ErrorReporter.js
-init_process();
-init_buffer();
-var Severity = {
-  Critical: "CRITICAL",
-  Warning: "WARNING"
-};
-var ErrorReporter = class _ErrorReporter {
-  constructor() {
-    __publicField(this, "errors");
-    __publicField(this, "path");
-    this.errors = [];
-    this.path = [];
-  }
-  add(err) {
-    this.errors.push(__spreadProps(__spreadValues({}, err), {
-      path: [...this.path]
-    }));
-  }
-  scope(path) {
-    this.path.push(path);
-  }
-  unscope() {
-    this.path.pop();
-  }
-  getBySeverity(severity) {
-    return this.errors.filter((err) => err.severity === severity);
-  }
-  empty() {
-    return this.errors.length === 0;
-  }
-  size() {
-    return this.errors.length;
-  }
-  clone() {
-    const clone = new _ErrorReporter();
-    clone.errors = [...this.errors];
-    clone.path = [...this.path];
-    return clone;
-  }
-  reset() {
-    this.errors = [];
-    this.path = [];
-  }
-  toDynamicSnippetErrors() {
-    return this.errors.map((err) => ({
-      severity: err.severity,
-      path: err.path != null ? this.pathToStringArray(err.path) : void 0,
-      message: err.message
-    }));
-  }
-  pathToStringArray(path) {
-    const result = [];
-    for (const item of path) {
-      if (typeof item === "string") {
-        result.push(item);
-        continue;
-      }
-      result[result.length - 1] += `[${item.index}]`;
-    }
-    return result;
-  }
-};
-
-// ../../browser-compatible-base/lib/dynamic-snippets/AbstractDynamicSnippetsGeneratorContext.js
-init_process();
-init_buffer();
-
-// ../../../packages/cli/fern-definition/schema/lib/index.js
-init_process();
-init_buffer();
-
-// ../../../packages/cli/fern-definition/schema/lib/utils/HttpEndpointReferenceParser.js
-init_process();
-init_buffer();
-var HttpEndpointReferenceParser = class {
-  constructor() {
-    //eslint-disable-next-line
-    __publicField(this, "REFERENCE_REGEX", /^(GET|POST|PUT|DELETE|PATCH)\s(\/[a-zA-Z0-9\/{}_-]*)$/);
-  }
-  validate(reference) {
-    const validFormat = this.REFERENCE_REGEX.test(reference);
-    if (!validFormat) {
-      return { type: "invalid" };
-    }
-    return { type: "valid" };
-  }
-  tryParse(reference) {
-    const validationResponse = this.validate(reference);
-    if (validationResponse.type === "invalid") {
-      return void 0;
-    }
-    const match = reference.match(this.REFERENCE_REGEX);
-    if (match == null || match[1] == null || match[2] == null) {
-      return void 0;
-    }
-    return {
-      method: match[1],
-      path: match[2]
-    };
-  }
-};
-
-// ../../browser-compatible-base/lib/dynamic-snippets/AbstractDynamicSnippetsGeneratorContext.js
-var AbstractDynamicSnippetsGeneratorContext = class {
-  constructor({ ir, config }) {
-    __publicField(this, "config");
-    __publicField(this, "errors");
-    __publicField(this, "_ir");
-    __publicField(this, "httpEndpointReferenceParser");
-    this._ir = ir;
-    this.config = config;
-    this.errors = new ErrorReporter();
-    this.httpEndpointReferenceParser = new HttpEndpointReferenceParser();
-  }
-  associateQueryParametersByWireValue({ parameters, values }) {
-    const instances = [];
-    for (const [key, value] of Object.entries(values)) {
-      this.errors.scope(key);
-      try {
-        const parameter = parameters.find((param) => param.name.wireValue === key);
-        if (parameter == null) {
-          throw this.newParameterNotRecognizedError(key);
-        }
-        const typeInstanceValue = this.isListTypeReference(parameter.typeReference) && !Array.isArray(value) ? [value] : value;
-        instances.push({
-          name: parameter.name,
-          typeReference: parameter.typeReference,
-          value: typeInstanceValue
-        });
-      } finally {
-        this.errors.unscope();
-      }
-    }
-    return instances;
-  }
-  associateByWireValue({ parameters, values, ignoreMissingParameters }) {
-    const instances = [];
-    for (const [key, value] of Object.entries(values)) {
-      this.errors.scope(key);
-      try {
-        const parameter = parameters.find((param) => param.name.wireValue === key);
-        if (parameter == null) {
-          if (ignoreMissingParameters) {
-            continue;
-          }
-          this.errors.add({
-            severity: Severity.Critical,
-            message: this.newParameterNotRecognizedError(key).message
-          });
-          continue;
-        }
-        instances.push({
-          name: parameter.name,
-          typeReference: parameter.typeReference,
-          value
-        });
-      } finally {
-        this.errors.unscope();
-      }
-    }
-    return instances;
-  }
-  getSingleFileValue({ property, record }) {
-    const fileValue = record[property.wireValue];
-    if (fileValue == null) {
-      return void 0;
-    }
-    if (typeof fileValue !== "string") {
-      this.errors.add({
-        severity: Severity.Critical,
-        message: `Expected file value to be a string, got ${typeof fileValue}`
-      });
-      return void 0;
-    }
-    return fileValue;
-  }
-  getFileArrayValues({ property, record }) {
-    const fileArrayValue = record[property.wireValue];
-    if (fileArrayValue == null) {
-      return void 0;
-    }
-    if (!Array.isArray(fileArrayValue)) {
-      this.errors.add({
-        severity: Severity.Critical,
-        message: `Expected file array value to be an array of strings, got ${typeof fileArrayValue}`
-      });
-      return void 0;
-    }
-    const stringValues = [];
-    for (const value of fileArrayValue) {
-      if (typeof value !== "string") {
-        this.errors.add({
-          severity: Severity.Critical,
-          message: `Expected file array value to be an array of strings, got ${typeof value}`
-        });
-        return void 0;
-      }
-      stringValues.push(value);
-    }
-    return stringValues;
-  }
-  getRecord(value) {
-    if (typeof value !== "object" || Array.isArray(value)) {
-      this.errors.add({
-        severity: Severity.Critical,
-        message: `Expected object with key, value pairs but got: ${Array.isArray(value) ? "array" : typeof value}`
-      });
-      return void 0;
-    }
-    if (value == null) {
-      return {};
-    }
-    return value;
-  }
-  resolveNamedType({ typeId }) {
-    const namedType = this._ir.types[typeId];
-    if (namedType == null) {
-      this.errors.add({
-        severity: Severity.Critical,
-        message: `Type identified by "${typeId}" could not be found`
-      });
-      return void 0;
-    }
-    return namedType;
-  }
-  resolveDiscriminatedUnionTypeInstance({ discriminatedUnion, value }) {
-    const record = this.getRecord(value);
-    if (record == null) {
-      return void 0;
-    }
-    const discriminantFieldName = discriminatedUnion.discriminant.wireValue;
-    const discriminantValue = record[discriminantFieldName];
-    if (discriminantValue == null) {
-      this.errors.add({
-        severity: Severity.Critical,
-        message: this.newParameterNotRecognizedError(discriminantFieldName).message
-      });
-      return void 0;
-    }
-    if (typeof discriminantValue !== "string") {
-      this.errors.add({
-        severity: Severity.Critical,
-        message: `Expected discriminant value to be a string but got: ${typeof discriminantValue}`
-      });
-      return void 0;
-    }
-    const singleDiscriminatedUnionType = discriminatedUnion.types[discriminantValue];
-    if (singleDiscriminatedUnionType == null) {
-      this.errors.add({
-        severity: Severity.Critical,
-        message: `No type found for discriminant value "${discriminantValue}"`
-      });
-      return void 0;
-    }
-    const _a = record, { [discriminantFieldName]: _ } = _a, filtered = __objRest(_a, [__restKey(discriminantFieldName)]);
-    return {
-      singleDiscriminatedUnionType,
-      discriminantValue: singleDiscriminatedUnionType.discriminantValue,
-      value: filtered
-    };
-  }
-  resolveEndpointOrThrow(rawEndpoint) {
-    const parsedEndpoint = this.httpEndpointReferenceParser.tryParse(rawEndpoint);
-    if (parsedEndpoint == null) {
-      throw new Error(`Failed to parse endpoint reference "${rawEndpoint}"`);
-    }
-    return this.resolveEndpointLocationOrThrow(parsedEndpoint);
-  }
-  resolveEndpointLocationOrThrow(location) {
-    const endpoints = [];
-    for (const endpoint of Object.values(this._ir.endpoints)) {
-      if (this.parsedEndpointMatches({ endpoint, parsedEndpoint: location })) {
-        endpoints.push(endpoint);
-      }
-    }
-    if (endpoints.length === 0) {
-      throw new Error(`Failed to find endpoint identified by "${location.method} ${location.path}"`);
-    }
-    return endpoints;
-  }
-  needsRequestParameter({ request, inlinePathParameters, inlineFileProperties }) {
-    var _a;
-    if (this.includePathParametersInWrappedRequest({ request, inlinePathParameters })) {
-      return true;
-    }
-    if (request.queryParameters != null && request.queryParameters.length > 0) {
-      return true;
-    }
-    if (request.headers != null && request.headers.length > 0) {
-      return true;
-    }
-    if (request.body != null) {
-      return this.includeRequestBodyInWrappedRequest({ body: request.body, inlineFileProperties });
-    }
-    if ((_a = request.metadata) == null ? void 0 : _a.onlyPathParameters) {
-      return false;
-    }
-    return true;
-  }
-  includePathParametersInWrappedRequest({ request, inlinePathParameters }) {
-    var _a, _b;
-    return inlinePathParameters && ((_b = (_a = request.metadata) == null ? void 0 : _a.includePathParameters) != null ? _b : false);
-  }
-  isFileUploadRequestBody(body) {
-    switch (body.type) {
-      case "fileUpload":
-        return true;
-      case "properties":
-      case "referenced":
-        return false;
-      default:
-        assertNever(body);
-    }
-  }
-  resolveEnvironmentName(environmentID) {
-    if (this._ir.environments == null) {
-      return void 0;
-    }
-    const environments = this._ir.environments.environments;
-    switch (environments.type) {
-      case "singleBaseUrl": {
-        const environment = environments.environments.find((env) => env.id === environmentID);
-        if (environment == null) {
-          return void 0;
-        }
-        return environment.name;
-      }
-      case "multipleBaseUrls": {
-        const environment = environments.environments.find((env) => env.id === environmentID);
-        if (environment == null) {
-          return void 0;
-        }
-        return environment.name;
-      }
-      default:
-        assertNever(environments);
-    }
-  }
-  isSingleEnvironmentID(environment) {
-    return typeof environment === "string";
-  }
-  isMultiEnvironmentValues(environment) {
-    return typeof environment === "object";
-  }
-  validateMultiEnvironmentUrlValues(multiEnvironmentUrlValues) {
-    if (this._ir.environments == null) {
-      this.errors.add({
-        severity: Severity.Critical,
-        message: "Multiple environments are not supported for single base URL environments; use the baseUrl option instead"
-      });
-      return false;
-    }
-    const environments = this._ir.environments.environments;
-    switch (environments.type) {
-      case "singleBaseUrl": {
-        this.errors.add({
-          severity: Severity.Critical,
-          message: "Multiple environments are not supported for single base URL environments; use the baseUrl option instead"
-        });
-        return false;
-      }
-      case "multipleBaseUrls": {
-        const firstEnvironment = environments.environments[0];
-        if (firstEnvironment == null) {
-          this.errors.add({
-            severity: Severity.Critical,
-            message: "Multiple environments are not supported; use the baseUrl option instead"
-          });
-          return false;
-        }
-        const expectedKeys = new Set(keys(firstEnvironment.urls));
-        for (const key of keys(multiEnvironmentUrlValues)) {
-          if (expectedKeys.has(key)) {
-            expectedKeys.delete(key);
-          }
-        }
-        if (expectedKeys.size > 0) {
-          this.errors.add({
-            severity: Severity.Critical,
-            message: `The provided environments are invalid; got: [${Object.keys(multiEnvironmentUrlValues).join(", ")}], expected: [${keys(firstEnvironment.urls).join(", ")}]`
-          });
-          return false;
-        }
-        return true;
-      }
-    }
-  }
-  getValueAsNumber({ value }) {
-    if (typeof value !== "number") {
-      this.errors.add({
-        severity: Severity.Critical,
-        message: this.newTypeMismatchError({ expected: "number", value }).message
-      });
-      return void 0;
-    }
-    return value;
-  }
-  getValueAsBoolean({ value }) {
-    if (typeof value !== "boolean") {
-      this.errors.add({
-        severity: Severity.Critical,
-        message: this.newTypeMismatchError({ expected: "boolean", value }).message
-      });
-      return void 0;
-    }
-    return value;
-  }
-  getValueAsString({ value }) {
-    if (typeof value !== "string") {
-      this.errors.add({
-        severity: Severity.Critical,
-        message: this.newTypeMismatchError({ expected: "string", value }).message
-      });
-      return void 0;
-    }
-    return value;
-  }
-  newAuthMismatchError({ auth, values }) {
-    return new Error(`Expected auth type ${auth.type}, got ${values.type}`);
-  }
-  newParameterNotRecognizedError(parameterName) {
-    return new Error(`"${parameterName}" is not a recognized parameter for this endpoint`);
-  }
-  newTypeMismatchError({ expected, value }) {
-    return new Error(`Expected ${expected}, got ${typeof value}`);
-  }
-  includeRequestBodyInWrappedRequest({ body, inlineFileProperties }) {
-    switch (body.type) {
-      case "properties":
-      case "referenced":
-        return true;
-      case "fileUpload":
-        return this.includeFileUploadBodyInWrappedRequest({ fileUpload: body, inlineFileProperties });
-      default:
-        assertNever(body);
-    }
-  }
-  includeFileUploadBodyInWrappedRequest({ fileUpload, inlineFileProperties }) {
-    return this.fileUploadHasBodyProperties({ fileUpload }) || inlineFileProperties && this.fileUploadHasFileProperties({ fileUpload });
-  }
-  fileUploadHasBodyProperties({ fileUpload }) {
-    return fileUpload.properties.some((property) => {
-      switch (property.type) {
-        case "file":
-        case "fileArray":
-          return false;
-        case "bodyProperty":
-          return true;
-        default:
-          assertNever(property);
-      }
-    });
-  }
-  fileUploadHasFileProperties({ fileUpload }) {
-    return fileUpload.properties.some((property) => {
-      switch (property.type) {
-        case "file":
-        case "fileArray":
-          return true;
-        case "bodyProperty":
-          return false;
-        default:
-          assertNever(property);
-      }
-    });
-  }
-  isListTypeReference(typeReference) {
-    if (typeReference.type === "optional") {
-      return this.isListTypeReference(typeReference.value);
-    }
-    return typeReference.type === "list" || typeReference.type === "set";
-  }
-  parsedEndpointMatches({ endpoint, parsedEndpoint }) {
-    return endpoint.location.method === parsedEndpoint.method && endpoint.location.path === parsedEndpoint.path;
-  }
-};
-
-// ../../browser-compatible-base/lib/dynamic-snippets/Result.js
-init_process();
-init_buffer();
-var Result = class {
-  constructor() {
-    __publicField(this, "reporter");
-    __publicField(this, "snippet");
-    __publicField(this, "err");
-    this.snippet = void 0;
-    this.reporter = void 0;
-    this.err = void 0;
-  }
-  update({ context, snippet }) {
-    if (this.reporter == null || this.reporter.size() > context.errors.size()) {
-      this.reporter = context.errors.clone();
-      this.snippet = snippet;
-    }
-  }
-  getResponseOrThrow({ endpoint }) {
-    var _a;
-    if (this.snippet != null && this.reporter != null) {
-      return {
-        snippet: this.snippet,
-        errors: this.reporter.toDynamicSnippetErrors()
-      };
-    }
-    throw (_a = this.err) != null ? _a : new Error(`Failed to generate snippet for endpoint "${endpoint.method} ${endpoint.path}"`);
-  }
-};
-
-// ../../browser-compatible-base/lib/dynamic-snippets/Scope.js
-init_process();
-init_buffer();
-var Scope = {
-  PathParameters: "pathParameters",
-  QueryParameters: "queryParameters",
-  Headers: "headers",
-  RequestBody: "requestBody"
-};
-
-// ../../browser-compatible-base/lib/dynamic-snippets/index.js
-init_process();
-init_buffer();
-
-export {
-  AbstractDynamicSnippetsGenerator,
-  Severity,
-  AbstractDynamicSnippetsGeneratorContext,
-  Result,
-  Scope
-};