@hashgraphonline/standards-agent-kit/dist/es/standards-agent-kit.es45.js

A modular SDK for building on-chain autonomous agents using Hashgraph Online Standards, including HCS-10 for agent discovery and communication. https://hol.org

import { getInnerSchema, hasRenderConfig, getRenderConfig, extractFieldMetadata } from "./standards-agent-kit.es44.js";
function extractRenderConfigs(schema) {
  const fields = {};
  const groups = {};
  const order = [];
  const metadata = {};
  extractFromSchema(schema, "", fields, groups, order, metadata);
  return {
    fields,
    groups: organizeFieldGroups(groups),
    order: orderFields(order, fields),
    metadata
  };
}
function extractFromSchema(schema, pathPrefix, fields, groups, order, metadata) {
  const innerSchema = getInnerSchema(schema);
  const typeName = innerSchema._def?.typeName;
  if (typeName === "ZodObject") {
    extractFromObjectSchema(innerSchema, pathPrefix, fields, groups, order, metadata);
  } else if (typeName === "ZodArray") {
    extractFromArraySchema(innerSchema, pathPrefix, fields, groups, order, metadata);
  } else {
    extractFromPrimitiveSchema(schema, pathPrefix, fields, groups, order, metadata);
  }
}
function extractFromObjectSchema(schema, pathPrefix, fields, groups, order, metadata) {
  const shape = schema.shape;
  if (hasRenderConfig(schema)) {
    const config = getRenderConfig(schema);
    if (config && pathPrefix) {
      fields[pathPrefix] = config;
      addToGroup(groups, config.ui?.group || "default", pathPrefix);
      addToOrder(order, pathPrefix, config.ui?.order);
    }
  }
  for (const [key, fieldSchema] of Object.entries(shape)) {
    const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
    extractFromSchema(fieldSchema, fieldPath, fields, groups, order, metadata);
  }
}
function extractFromArraySchema(schema, pathPrefix, fields, groups, order, metadata) {
  if (hasRenderConfig(schema)) {
    const config = getRenderConfig(schema);
    if (config) {
      fields[pathPrefix] = config;
      addToGroup(groups, config.ui?.group || "default", pathPrefix);
      addToOrder(order, pathPrefix, config.ui?.order);
      metadata[pathPrefix] = extractFieldMetadata(schema);
    }
  }
  const elementSchema = schema._def.type;
  if (elementSchema) {
    const itemPath = `${pathPrefix}[]`;
    extractFromSchema(elementSchema, itemPath, fields, groups, order, metadata);
  }
}
function extractFromPrimitiveSchema(schema, pathPrefix, fields, groups, order, metadata) {
  if (hasRenderConfig(schema)) {
    const config = getRenderConfig(schema);
    if (config) {
      fields[pathPrefix] = config;
      addToGroup(groups, config.ui?.group || "default", pathPrefix);
      addToOrder(order, pathPrefix, config.ui?.order);
    }
  }
  metadata[pathPrefix] = extractFieldMetadata(schema);
}
function addToGroup(groups, groupName, fieldPath) {
  if (!groups[groupName]) {
    groups[groupName] = [];
  }
  groups[groupName].push(fieldPath);
}
function addToOrder(order, fieldPath, explicitOrder) {
  if (explicitOrder !== void 0) {
    order.splice(explicitOrder, 0, fieldPath);
  } else {
    order.push(fieldPath);
  }
}
function organizeFieldGroups(groups) {
  const organized = {};
  const groupPriority = ["default", "Keys & Security", "Token Settings", "Custom Fees"];
  for (const groupName of groupPriority) {
    if (groups[groupName]) {
      organized[groupName] = groups[groupName];
    }
  }
  for (const [groupName, fields] of Object.entries(groups)) {
    if (!groupPriority.includes(groupName)) {
      organized[groupName] = fields;
    }
  }
  return organized;
}
function orderFields(order, fields) {
  const fieldPriority = {
    "tokenName": 1,
    "tokenSymbol": 2,
    "maxSupply": 3,
    "supplyType": 4,
    "treasuryAccountId": 5,
    "memo": 6
  };
  return order.sort((a, b) => {
    const aConfig = fields[a];
    const bConfig = fields[b];
    if (aConfig?.ui?.order !== void 0 && bConfig?.ui?.order !== void 0) {
      return aConfig.ui.order - bConfig.ui.order;
    }
    if (aConfig?.ui?.order !== void 0) {
      return -1;
    }
    if (bConfig?.ui?.order !== void 0) {
      return 1;
    }
    const aPriority = fieldPriority[a] || 1e3;
    const bPriority = fieldPriority[b] || 1e3;
    if (aPriority !== bPriority) {
      return aPriority - bPriority;
    }
    return a.localeCompare(b);
  });
}
function generateFieldOrdering(schema) {
  const extracted = extractRenderConfigs(schema);
  const sections = {};
  const sectionOrder = {
    "default": 0,
    "Basic Information": 1,
    "Token Settings": 2,
    "Keys & Security": 3,
    "Custom Fees": 4,
    "Advanced Settings": 5
  };
  for (const [groupName, fields] of Object.entries(extracted.groups)) {
    const displayName = groupName === "default" ? "Basic Information" : groupName;
    sections[displayName] = {
      title: displayName,
      fields,
      order: sectionOrder[displayName] || 10
    };
  }
  return {
    sections,
    fieldOrder: extracted.order
  };
}
function createFieldConfigMap(schema) {
  const extracted = extractRenderConfigs(schema);
  const configMap = {};
  for (const [fieldPath, renderConfig] of Object.entries(extracted.fields)) {
    const metadata = extracted.metadata[fieldPath];
    const path = fieldPath.split(".");
    configMap[fieldPath] = {
      renderConfig,
      metadata,
      path
    };
  }
  return configMap;
}
function createSimpleConfig(schema) {
  const extracted = extractRenderConfigs(schema);
  const fields = [];
  for (const fieldPath of extracted.order) {
    const renderConfig = extracted.fields[fieldPath];
    const metadata = extracted.metadata[fieldPath];
    if (!renderConfig || !metadata) {
      continue;
    }
    fields.push({
      name: fieldPath,
      type: metadata.type,
      label: renderConfig.ui?.label || fieldPath,
      required: metadata.required,
      placeholder: renderConfig.ui?.placeholder,
      options: renderConfig.options || metadata.options
    });
  }
  return { fields };
}
export {
  createFieldConfigMap,
  createSimpleConfig,
  extractRenderConfigs,
  generateFieldOrdering
};
//# sourceMappingURL=standards-agent-kit.es45.js.map