@uniformdev/mesh-edgehancer-sdk 19.79.1-alpha.13

package/dist/index.esm.js

@@ -0,0 +1,194 @@
+// src/batchUtils.ts
+function convertBatchResultsToEdgehancerResult({
+  batch,
+  batchFetchIds: { invalidBatchIndices, validIdToOriginalIndexMap },
+  batchResults,
+  resolveIdFromBatchResultFn,
+  knownInvalidErrorMessage = "batch request ID could not be read from the data resource",
+  missingBatchResultErrorMessage = () => "batch request did not return a result for the data resource ID"
+}) {
+  const results = new Array(batch.length);
+  if (!Array.isArray(batchResults)) {
+    throw new Error(`batchResults is not an array (got ${typeof batchResults})`);
+  }
+  for (const batchResult of batchResults) {
+    const resultId = resolveIdFromBatchResultFn(batchResult);
+    const batchIndex = validIdToOriginalIndexMap.get(resultId);
+    if (batchIndex !== void 0) {
+      results[batchIndex] = {
+        result: batchResult
+      };
+    }
+  }
+  for (const batchIndex of invalidBatchIndices) {
+    results[batchIndex] = {
+      errors: [knownInvalidErrorMessage]
+    };
+  }
+  for (let batchIndex = 0; batchIndex < results.length; batchIndex++) {
+    if (results[batchIndex] === void 0) {
+      results[batchIndex] = {
+        errors: [missingBatchResultErrorMessage(batch[batchIndex])]
+      };
+    }
+  }
+  return results;
+}
+function resolveBatchFetchIds(batch, resolveBatchItemIdFn) {
+  const result = {
+    invalidBatchIndices: /* @__PURE__ */ new Set(),
+    validIds: [],
+    validIdToOriginalIndexMap: /* @__PURE__ */ new Map()
+  };
+  batch.forEach((context, batchIndex) => {
+    const id = resolveBatchItemIdFn(context);
+    if (id === void 0) {
+      result.invalidBatchIndices.add(batchIndex);
+      return;
+    }
+    result.validIdToOriginalIndexMap.set(id, batchIndex);
+    result.validIds.push(id);
+  });
+  return result;
+}
+
+// src/fetchUtils.ts
+function getDataResourceAsRequest(data) {
+  var _a;
+  const method = (_a = data.method) != null ? _a : "GET";
+  const body = method === "POST" ? data.body : void 0;
+  const headers = getDataResourceHeaders(data);
+  const url = getDataResourceUrl(data);
+  return new Request(url, { method, headers, body });
+}
+function getDataResourceUrl(dataResource) {
+  const urlParts = dataResource.url.split("?");
+  const queryString = getDataResourceQueryString(dataResource);
+  const url = new URL(urlParts[0]).toString();
+  return url + (queryString.length > 0 ? `?${queryString}` : "");
+}
+function getDataResourceQueryString({ parameters, url }) {
+  const urlParts = url.split("?");
+  const searchParams = copyKeyValuePairs(parameters, new URLSearchParams(urlParts[1]));
+  return Array.from(searchParams).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+}
+function getDataResourceHeaders({ headers }) {
+  return copyKeyValuePairs(headers, new Headers());
+}
+function copyKeyValuePairs(source, target) {
+  if (Array.isArray(source)) {
+    [...source].sort((a, b) => a.key.localeCompare(b.key)).forEach(({ key, value, omitIfEmpty }) => {
+      if (value || !omitIfEmpty) {
+        target.append(key, value);
+      }
+    });
+  } else if (source) {
+    Object.keys(source).sort((a, b) => a.localeCompare(b)).forEach((key) => {
+      target.append(key, source[key]);
+    });
+  }
+  return target;
+}
+
+// src/preRequest.ts
+import { z as z2 } from "zod";
+
+// src/shared.ts
+import { assert } from "tsafe";
+import { z } from "zod";
+var parameterDefinitionSchema = z.object({
+  key: z.string(),
+  value: z.string(),
+  omitIfEmpty: z.boolean().optional()
+});
+var variableDefinitionSchema = z.object({
+  displayName: z.string().optional(),
+  type: z.string().optional(),
+  default: z.string(),
+  helpText: z.string().optional(),
+  order: z.number().optional(),
+  source: z.string().optional()
+});
+var customEdgehancerDefinitionSchema = z.object({
+  preRequest: z.string().optional(),
+  request: z.string().optional()
+});
+var mergedDataTypeSchema = z.object({
+  id: z.string(),
+  displayName: z.string(),
+  archetype: z.string().optional(),
+  allowedOnComponents: z.array(z.string()).optional(),
+  badgeIconUrl: z.string().optional(),
+  connectorType: z.string(),
+  url: z.string(),
+  headers: z.array(parameterDefinitionSchema).optional(),
+  parameters: z.array(parameterDefinitionSchema).optional(),
+  body: z.string().optional(),
+  method: z.enum(["GET", "POST", "HEAD"]),
+  variables: z.record(variableDefinitionSchema).optional(),
+  custom: z.record(z.unknown()).optional(),
+  ttl: z.number().optional(),
+  purgeKey: z.string().optional(),
+  localeMapping: z.record(z.string()).optional(),
+  edgehancer: customEdgehancerDefinitionSchema.optional(),
+  uiBadgeText: z.string().max(12).optional()
+});
+assert();
+var dataResourceSchema = z.union([
+  z.string(),
+  z.object({}).catchall(z.unknown()),
+  z.number(),
+  z.boolean(),
+  z.array(z.unknown()),
+  z.undefined()
+]);
+
+// src/preRequest.ts
+var edgehancerMergedDataTypeSchema = mergedDataTypeSchema.omit({
+  edgehancer: true,
+  allowedOnComponents: true,
+  badgeIconUrl: true,
+  displayName: true,
+  id: true,
+  purgeKey: true,
+  variables: true
+});
+var preRequestEdgehancerDataResourceResultSchema = z2.strictObject({
+  errors: z2.array(z2.string()).optional(),
+  warnings: z2.array(z2.string()).optional(),
+  dataResource: edgehancerMergedDataTypeSchema
+});
+var preRequestEdgehancerResultSchema = z2.strictObject({
+  dataResources: z2.array(preRequestEdgehancerDataResourceResultSchema)
+});
+
+// src/request.ts
+import { z as z3 } from "zod";
+var requestEdgehancerDataResourceResolutionResultSchema = z3.strictObject({
+  errors: z3.array(z3.string()).optional().describe(
+    "Errors that occurred while running your code to return with the API response, if any. Unhandled exceptions will be captured automatically."
+  ),
+  warnings: z3.array(z3.string()).optional().describe("Warnings that occurred while running your code to return with the API response, if any."),
+  surrogateKeys: z3.array(z3.string()).optional().describe(
+    "Extra surrogate keys for the data that was fetched. These act as auxiliary cache keys that can allow granular purging of cached data."
+  ),
+  result: dataResourceSchema.describe("The result of fetching the data resource")
+});
+var requestEdgehancerResultSchema = z3.strictObject({
+  results: z3.array(requestEdgehancerDataResourceResolutionResultSchema)
+});
+export {
+  convertBatchResultsToEdgehancerResult,
+  dataResourceSchema,
+  edgehancerMergedDataTypeSchema,
+  getDataResourceAsRequest,
+  getDataResourceHeaders,
+  getDataResourceQueryString,
+  getDataResourceUrl,
+  mergedDataTypeSchema,
+  preRequestEdgehancerDataResourceResultSchema,
+  preRequestEdgehancerResultSchema,
+  requestEdgehancerDataResourceResolutionResultSchema,
+  requestEdgehancerResultSchema,
+  resolveBatchFetchIds
+};

package/dist/index.js

@@ -0,0 +1,233 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  convertBatchResultsToEdgehancerResult: () => convertBatchResultsToEdgehancerResult,
+  dataResourceSchema: () => dataResourceSchema,
+  edgehancerMergedDataTypeSchema: () => edgehancerMergedDataTypeSchema,
+  getDataResourceAsRequest: () => getDataResourceAsRequest,
+  getDataResourceHeaders: () => getDataResourceHeaders,
+  getDataResourceQueryString: () => getDataResourceQueryString,
+  getDataResourceUrl: () => getDataResourceUrl,
+  mergedDataTypeSchema: () => mergedDataTypeSchema,
+  preRequestEdgehancerDataResourceResultSchema: () => preRequestEdgehancerDataResourceResultSchema,
+  preRequestEdgehancerResultSchema: () => preRequestEdgehancerResultSchema,
+  requestEdgehancerDataResourceResolutionResultSchema: () => requestEdgehancerDataResourceResolutionResultSchema,
+  requestEdgehancerResultSchema: () => requestEdgehancerResultSchema,
+  resolveBatchFetchIds: () => resolveBatchFetchIds
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/batchUtils.ts
+function convertBatchResultsToEdgehancerResult({
+  batch,
+  batchFetchIds: { invalidBatchIndices, validIdToOriginalIndexMap },
+  batchResults,
+  resolveIdFromBatchResultFn,
+  knownInvalidErrorMessage = "batch request ID could not be read from the data resource",
+  missingBatchResultErrorMessage = () => "batch request did not return a result for the data resource ID"
+}) {
+  const results = new Array(batch.length);
+  if (!Array.isArray(batchResults)) {
+    throw new Error(`batchResults is not an array (got ${typeof batchResults})`);
+  }
+  for (const batchResult of batchResults) {
+    const resultId = resolveIdFromBatchResultFn(batchResult);
+    const batchIndex = validIdToOriginalIndexMap.get(resultId);
+    if (batchIndex !== void 0) {
+      results[batchIndex] = {
+        result: batchResult
+      };
+    }
+  }
+  for (const batchIndex of invalidBatchIndices) {
+    results[batchIndex] = {
+      errors: [knownInvalidErrorMessage]
+    };
+  }
+  for (let batchIndex = 0; batchIndex < results.length; batchIndex++) {
+    if (results[batchIndex] === void 0) {
+      results[batchIndex] = {
+        errors: [missingBatchResultErrorMessage(batch[batchIndex])]
+      };
+    }
+  }
+  return results;
+}
+function resolveBatchFetchIds(batch, resolveBatchItemIdFn) {
+  const result = {
+    invalidBatchIndices: /* @__PURE__ */ new Set(),
+    validIds: [],
+    validIdToOriginalIndexMap: /* @__PURE__ */ new Map()
+  };
+  batch.forEach((context, batchIndex) => {
+    const id = resolveBatchItemIdFn(context);
+    if (id === void 0) {
+      result.invalidBatchIndices.add(batchIndex);
+      return;
+    }
+    result.validIdToOriginalIndexMap.set(id, batchIndex);
+    result.validIds.push(id);
+  });
+  return result;
+}
+
+// src/fetchUtils.ts
+function getDataResourceAsRequest(data) {
+  var _a;
+  const method = (_a = data.method) != null ? _a : "GET";
+  const body = method === "POST" ? data.body : void 0;
+  const headers = getDataResourceHeaders(data);
+  const url = getDataResourceUrl(data);
+  return new Request(url, { method, headers, body });
+}
+function getDataResourceUrl(dataResource) {
+  const urlParts = dataResource.url.split("?");
+  const queryString = getDataResourceQueryString(dataResource);
+  const url = new URL(urlParts[0]).toString();
+  return url + (queryString.length > 0 ? `?${queryString}` : "");
+}
+function getDataResourceQueryString({ parameters, url }) {
+  const urlParts = url.split("?");
+  const searchParams = copyKeyValuePairs(parameters, new URLSearchParams(urlParts[1]));
+  return Array.from(searchParams).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+}
+function getDataResourceHeaders({ headers }) {
+  return copyKeyValuePairs(headers, new Headers());
+}
+function copyKeyValuePairs(source, target) {
+  if (Array.isArray(source)) {
+    [...source].sort((a, b) => a.key.localeCompare(b.key)).forEach(({ key, value, omitIfEmpty }) => {
+      if (value || !omitIfEmpty) {
+        target.append(key, value);
+      }
+    });
+  } else if (source) {
+    Object.keys(source).sort((a, b) => a.localeCompare(b)).forEach((key) => {
+      target.append(key, source[key]);
+    });
+  }
+  return target;
+}
+
+// src/preRequest.ts
+var import_zod2 = require("zod");
+
+// src/shared.ts
+var import_tsafe = require("tsafe");
+var import_zod = require("zod");
+var parameterDefinitionSchema = import_zod.z.object({
+  key: import_zod.z.string(),
+  value: import_zod.z.string(),
+  omitIfEmpty: import_zod.z.boolean().optional()
+});
+var variableDefinitionSchema = import_zod.z.object({
+  displayName: import_zod.z.string().optional(),
+  type: import_zod.z.string().optional(),
+  default: import_zod.z.string(),
+  helpText: import_zod.z.string().optional(),
+  order: import_zod.z.number().optional(),
+  source: import_zod.z.string().optional()
+});
+var customEdgehancerDefinitionSchema = import_zod.z.object({
+  preRequest: import_zod.z.string().optional(),
+  request: import_zod.z.string().optional()
+});
+var mergedDataTypeSchema = import_zod.z.object({
+  id: import_zod.z.string(),
+  displayName: import_zod.z.string(),
+  archetype: import_zod.z.string().optional(),
+  allowedOnComponents: import_zod.z.array(import_zod.z.string()).optional(),
+  badgeIconUrl: import_zod.z.string().optional(),
+  connectorType: import_zod.z.string(),
+  url: import_zod.z.string(),
+  headers: import_zod.z.array(parameterDefinitionSchema).optional(),
+  parameters: import_zod.z.array(parameterDefinitionSchema).optional(),
+  body: import_zod.z.string().optional(),
+  method: import_zod.z.enum(["GET", "POST", "HEAD"]),
+  variables: import_zod.z.record(variableDefinitionSchema).optional(),
+  custom: import_zod.z.record(import_zod.z.unknown()).optional(),
+  ttl: import_zod.z.number().optional(),
+  purgeKey: import_zod.z.string().optional(),
+  localeMapping: import_zod.z.record(import_zod.z.string()).optional(),
+  edgehancer: customEdgehancerDefinitionSchema.optional(),
+  uiBadgeText: import_zod.z.string().max(12).optional()
+});
+(0, import_tsafe.assert)();
+var dataResourceSchema = import_zod.z.union([
+  import_zod.z.string(),
+  import_zod.z.object({}).catchall(import_zod.z.unknown()),
+  import_zod.z.number(),
+  import_zod.z.boolean(),
+  import_zod.z.array(import_zod.z.unknown()),
+  import_zod.z.undefined()
+]);
+
+// src/preRequest.ts
+var edgehancerMergedDataTypeSchema = mergedDataTypeSchema.omit({
+  edgehancer: true,
+  allowedOnComponents: true,
+  badgeIconUrl: true,
+  displayName: true,
+  id: true,
+  purgeKey: true,
+  variables: true
+});
+var preRequestEdgehancerDataResourceResultSchema = import_zod2.z.strictObject({
+  errors: import_zod2.z.array(import_zod2.z.string()).optional(),
+  warnings: import_zod2.z.array(import_zod2.z.string()).optional(),
+  dataResource: edgehancerMergedDataTypeSchema
+});
+var preRequestEdgehancerResultSchema = import_zod2.z.strictObject({
+  dataResources: import_zod2.z.array(preRequestEdgehancerDataResourceResultSchema)
+});
+
+// src/request.ts
+var import_zod3 = require("zod");
+var requestEdgehancerDataResourceResolutionResultSchema = import_zod3.z.strictObject({
+  errors: import_zod3.z.array(import_zod3.z.string()).optional().describe(
+    "Errors that occurred while running your code to return with the API response, if any. Unhandled exceptions will be captured automatically."
+  ),
+  warnings: import_zod3.z.array(import_zod3.z.string()).optional().describe("Warnings that occurred while running your code to return with the API response, if any."),
+  surrogateKeys: import_zod3.z.array(import_zod3.z.string()).optional().describe(
+    "Extra surrogate keys for the data that was fetched. These act as auxiliary cache keys that can allow granular purging of cached data."
+  ),
+  result: dataResourceSchema.describe("The result of fetching the data resource")
+});
+var requestEdgehancerResultSchema = import_zod3.z.strictObject({
+  results: import_zod3.z.array(requestEdgehancerDataResourceResolutionResultSchema)
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertBatchResultsToEdgehancerResult,
+  dataResourceSchema,
+  edgehancerMergedDataTypeSchema,
+  getDataResourceAsRequest,
+  getDataResourceHeaders,
+  getDataResourceQueryString,
+  getDataResourceUrl,
+  mergedDataTypeSchema,
+  preRequestEdgehancerDataResourceResultSchema,
+  preRequestEdgehancerResultSchema,
+  requestEdgehancerDataResourceResolutionResultSchema,
+  requestEdgehancerResultSchema,
+  resolveBatchFetchIds
+});

package/dist/index.mjs

@@ -0,0 +1,194 @@
+// src/batchUtils.ts
+function convertBatchResultsToEdgehancerResult({
+  batch,
+  batchFetchIds: { invalidBatchIndices, validIdToOriginalIndexMap },
+  batchResults,
+  resolveIdFromBatchResultFn,
+  knownInvalidErrorMessage = "batch request ID could not be read from the data resource",
+  missingBatchResultErrorMessage = () => "batch request did not return a result for the data resource ID"
+}) {
+  const results = new Array(batch.length);
+  if (!Array.isArray(batchResults)) {
+    throw new Error(`batchResults is not an array (got ${typeof batchResults})`);
+  }
+  for (const batchResult of batchResults) {
+    const resultId = resolveIdFromBatchResultFn(batchResult);
+    const batchIndex = validIdToOriginalIndexMap.get(resultId);
+    if (batchIndex !== void 0) {
+      results[batchIndex] = {
+        result: batchResult
+      };
+    }
+  }
+  for (const batchIndex of invalidBatchIndices) {
+    results[batchIndex] = {
+      errors: [knownInvalidErrorMessage]
+    };
+  }
+  for (let batchIndex = 0; batchIndex < results.length; batchIndex++) {
+    if (results[batchIndex] === void 0) {
+      results[batchIndex] = {
+        errors: [missingBatchResultErrorMessage(batch[batchIndex])]
+      };
+    }
+  }
+  return results;
+}
+function resolveBatchFetchIds(batch, resolveBatchItemIdFn) {
+  const result = {
+    invalidBatchIndices: /* @__PURE__ */ new Set(),
+    validIds: [],
+    validIdToOriginalIndexMap: /* @__PURE__ */ new Map()
+  };
+  batch.forEach((context, batchIndex) => {
+    const id = resolveBatchItemIdFn(context);
+    if (id === void 0) {
+      result.invalidBatchIndices.add(batchIndex);
+      return;
+    }
+    result.validIdToOriginalIndexMap.set(id, batchIndex);
+    result.validIds.push(id);
+  });
+  return result;
+}
+
+// src/fetchUtils.ts
+function getDataResourceAsRequest(data) {
+  var _a;
+  const method = (_a = data.method) != null ? _a : "GET";
+  const body = method === "POST" ? data.body : void 0;
+  const headers = getDataResourceHeaders(data);
+  const url = getDataResourceUrl(data);
+  return new Request(url, { method, headers, body });
+}
+function getDataResourceUrl(dataResource) {
+  const urlParts = dataResource.url.split("?");
+  const queryString = getDataResourceQueryString(dataResource);
+  const url = new URL(urlParts[0]).toString();
+  return url + (queryString.length > 0 ? `?${queryString}` : "");
+}
+function getDataResourceQueryString({ parameters, url }) {
+  const urlParts = url.split("?");
+  const searchParams = copyKeyValuePairs(parameters, new URLSearchParams(urlParts[1]));
+  return Array.from(searchParams).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`).join("&");
+}
+function getDataResourceHeaders({ headers }) {
+  return copyKeyValuePairs(headers, new Headers());
+}
+function copyKeyValuePairs(source, target) {
+  if (Array.isArray(source)) {
+    [...source].sort((a, b) => a.key.localeCompare(b.key)).forEach(({ key, value, omitIfEmpty }) => {
+      if (value || !omitIfEmpty) {
+        target.append(key, value);
+      }
+    });
+  } else if (source) {
+    Object.keys(source).sort((a, b) => a.localeCompare(b)).forEach((key) => {
+      target.append(key, source[key]);
+    });
+  }
+  return target;
+}
+
+// src/preRequest.ts
+import { z as z2 } from "zod";
+
+// src/shared.ts
+import { assert } from "tsafe";
+import { z } from "zod";
+var parameterDefinitionSchema = z.object({
+  key: z.string(),
+  value: z.string(),
+  omitIfEmpty: z.boolean().optional()
+});
+var variableDefinitionSchema = z.object({
+  displayName: z.string().optional(),
+  type: z.string().optional(),
+  default: z.string(),
+  helpText: z.string().optional(),
+  order: z.number().optional(),
+  source: z.string().optional()
+});
+var customEdgehancerDefinitionSchema = z.object({
+  preRequest: z.string().optional(),
+  request: z.string().optional()
+});
+var mergedDataTypeSchema = z.object({
+  id: z.string(),
+  displayName: z.string(),
+  archetype: z.string().optional(),
+  allowedOnComponents: z.array(z.string()).optional(),
+  badgeIconUrl: z.string().optional(),
+  connectorType: z.string(),
+  url: z.string(),
+  headers: z.array(parameterDefinitionSchema).optional(),
+  parameters: z.array(parameterDefinitionSchema).optional(),
+  body: z.string().optional(),
+  method: z.enum(["GET", "POST", "HEAD"]),
+  variables: z.record(variableDefinitionSchema).optional(),
+  custom: z.record(z.unknown()).optional(),
+  ttl: z.number().optional(),
+  purgeKey: z.string().optional(),
+  localeMapping: z.record(z.string()).optional(),
+  edgehancer: customEdgehancerDefinitionSchema.optional(),
+  uiBadgeText: z.string().max(12).optional()
+});
+assert();
+var dataResourceSchema = z.union([
+  z.string(),
+  z.object({}).catchall(z.unknown()),
+  z.number(),
+  z.boolean(),
+  z.array(z.unknown()),
+  z.undefined()
+]);
+
+// src/preRequest.ts
+var edgehancerMergedDataTypeSchema = mergedDataTypeSchema.omit({
+  edgehancer: true,
+  allowedOnComponents: true,
+  badgeIconUrl: true,
+  displayName: true,
+  id: true,
+  purgeKey: true,
+  variables: true
+});
+var preRequestEdgehancerDataResourceResultSchema = z2.strictObject({
+  errors: z2.array(z2.string()).optional(),
+  warnings: z2.array(z2.string()).optional(),
+  dataResource: edgehancerMergedDataTypeSchema
+});
+var preRequestEdgehancerResultSchema = z2.strictObject({
+  dataResources: z2.array(preRequestEdgehancerDataResourceResultSchema)
+});
+
+// src/request.ts
+import { z as z3 } from "zod";
+var requestEdgehancerDataResourceResolutionResultSchema = z3.strictObject({
+  errors: z3.array(z3.string()).optional().describe(
+    "Errors that occurred while running your code to return with the API response, if any. Unhandled exceptions will be captured automatically."
+  ),
+  warnings: z3.array(z3.string()).optional().describe("Warnings that occurred while running your code to return with the API response, if any."),
+  surrogateKeys: z3.array(z3.string()).optional().describe(
+    "Extra surrogate keys for the data that was fetched. These act as auxiliary cache keys that can allow granular purging of cached data."
+  ),
+  result: dataResourceSchema.describe("The result of fetching the data resource")
+});
+var requestEdgehancerResultSchema = z3.strictObject({
+  results: z3.array(requestEdgehancerDataResourceResolutionResultSchema)
+});
+export {
+  convertBatchResultsToEdgehancerResult,
+  dataResourceSchema,
+  edgehancerMergedDataTypeSchema,
+  getDataResourceAsRequest,
+  getDataResourceHeaders,
+  getDataResourceQueryString,
+  getDataResourceUrl,
+  mergedDataTypeSchema,
+  preRequestEdgehancerDataResourceResultSchema,
+  preRequestEdgehancerResultSchema,
+  requestEdgehancerDataResourceResolutionResultSchema,
+  requestEdgehancerResultSchema,
+  resolveBatchFetchIds
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@uniformdev/mesh-edgehancer-sdk",
+  "version": "19.79.1-alpha.13+608a273da",
+  "description": "Uniform Mesh Edgehancer SDK",
+  "license": "SEE LICENSE IN LICENSE.txt",
+  "main": "./dist/index.js",
+  "module": "./dist/index.esm.js",
+  "exports": {
+    "import": {
+      "types": "./dist/index.d.mts",
+      "node": "./dist/index.mjs",
+      "default": "./dist/index.esm.js"
+    },
+    "require": "./dist/index.js"
+  },
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rimraf dist",
+    "test": "jest --maxWorkers=1 --passWithNoTests",
+    "lint": "eslint \"src/**/*.{js,ts,tsx}\"",
+    "format": "prettier --write \"src/**/*.{js,ts,tsx}\"",
+    "document": "api-extractor run --local"
+  },
+  "files": [
+    "/dist"
+  ],
+  "dependencies": {
+    "@uniformdev/canvas": "19.79.1-alpha.13+608a273da",
+    "tsafe": "1.6.5",
+    "zod": "3.22.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "608a273da87aa432f17b2c8ce15d747dadab0cd1"
+}