@openpkg-ts/sdk 0.55.0 → 0.55.1

package/dist/index.js

@@ -18,6 +18,11 @@ import {
   groupByVisibility,
   isMethod,
   isProperty,
+  isRequiredOnlyAnyOf,
+  normalizeExport,
+  normalizeMembers,
+  normalizeSchema,
+  normalizeType,
   query,
   resolveTypeRef,
   sortByName,
@@ -25,7 +30,7 @@ import {
   toPagefindRecords,
   toSearchIndex,
   toSearchIndexJSON
-} from "./shared/chunk-pwvdnach.js";
+} from "./shared/chunk-jfjmy1r0.js";
 
 // src/primitives/diff.ts
 import {
@@ -2897,6 +2902,23 @@ function declaredTypeNode(decl) {
   const withType = decl;
   return withType?.type;
 }
+function propertyTypeNode(prop) {
+  const decls = prop.getDeclarations() ?? [];
+  if (decls.length <= 1)
+    return declaredTypeNode(prop.valueDeclaration ?? decls[0]);
+  const nodes = decls.map(declaredTypeNode).filter((n) => n !== undefined);
+  const informative = nodes.filter((n) => n.kind !== ts5.SyntaxKind.NeverKeyword && n.kind !== ts5.SyntaxKind.UndefinedKeyword);
+  const [first, ...rest] = informative.length > 0 ? informative : nodes;
+  if (!first)
+    return;
+  try {
+    const text = (n) => n.getText().replace(/\s+/g, " ");
+    const firstText = text(first);
+    return rest.every((n) => text(n) === firstText) ? first : undefined;
+  } catch {
+    return;
+  }
+}
 function typeNodeOfSignature(sig) {
   const decl = sig.getDeclaration();
   if (!decl || !ts5.isFunctionLike(decl))
@@ -3038,7 +3060,7 @@ function decoratePropertySchema(schema, prop, propType, checker) {
   let result = obj;
   if (!derivable && !("x-ts-type" in obj)) {
     result = { ...result, "x-ts-type": text };
-    const declared = writtenTypeText(declaredTypeNode(decl));
+    const declared = writtenTypeText(propertyTypeNode(prop));
     if (declared && declared !== text && !PRIMITIVES.has(declared) && !("x-ts-declared" in obj)) {
       result = { ...result, "x-ts-declared": declared };
     }
@@ -3977,8 +3999,7 @@ function buildObjectSchema(properties, checker, ctx, originalType) {
       const isOptionalProp = !!(prop.flags & ts5.SymbolFlags.Optional);
       const rawPropType = checker.getTypeOfSymbol(prop);
       const propType = isOptionalProp ? stripUndefinedFromType(rawPropType, checker) : rawPropType;
-      const decl = prop.valueDeclaration ?? prop.getDeclarations()?.[0];
-      let propSchema = buildSchema(propType, checker, ctx, declaredTypeNode(decl));
+      let propSchema = buildSchema(propType, checker, ctx, propertyTypeNode(prop));
       const docComment = prop.getDocumentationComment(checker);
       if (docComment.length > 0) {
         const description = docComment.map((c) => c.text).join(`
@@ -4645,12 +4666,22 @@ function resolvedProperties(type, checker) {
   const seen = new Map;
   for (const arm of objectArms(type, checker)) {
     for (const prop of armProperties(arm, checker)) {
-      if (!seen.has(prop.getName()))
-        seen.set(prop.getName(), prop);
+      const name = prop.getName();
+      const current = seen.get(name);
+      if (!current || isAbsentMarker(current, checker) && !isAbsentMarker(prop, checker)) {
+        seen.set(name, prop);
+      }
     }
   }
   return [...seen.values()];
 }
+function isAbsentMarker(prop, checker) {
+  const type = stripUndefinedFromType(checker.getTypeOfSymbol(prop), checker);
+  return !!(type.flags & (ts7.TypeFlags.Never | ts7.TypeFlags.Undefined));
+}
+function armRequiredNames(arm, checker) {
+  return new Set(armProperties(arm, checker).filter((p) => !(p.flags & ts7.SymbolFlags.Optional)).map((p) => p.getName()));
+}
 var PRIMITIVE_LIKE = ts7.TypeFlags.StringLike | ts7.TypeFlags.NumberLike | ts7.TypeFlags.BigIntLike | ts7.TypeFlags.BooleanLike | ts7.TypeFlags.ESSymbolLike | ts7.TypeFlags.Void | ts7.TypeFlags.Undefined | ts7.TypeFlags.Null;
 function objectArms(type, checker) {
   const arms = type.isUnion() ? type.types : [type];
@@ -4675,22 +4706,33 @@ function resolvedObjectSchema(schema, param, decl, isOptional, ctx) {
   const props = resolvedProperties(type, checker);
   const resolved = buildObjectSchema(props, checker, ctx, type);
   if (arms.length > 1) {
-    const requiredInAll = new Set(props.map((p) => p.getName()));
-    for (const arm of arms) {
-      const armRequired = new Set(armProperties(arm, checker).filter((p) => !(p.flags & ts7.SymbolFlags.Optional)).map((p) => p.getName()));
-      for (const name of [...requiredInAll])
-        if (!armRequired.has(name))
-          requiredInAll.delete(name);
-    }
-    const required = resolved.required?.filter((n) => requiredInAll.has(n));
-    if (required?.length)
+    const perArm = arms.map((arm) => armRequiredNames(arm, checker));
+    const requiredInAll = new Set(props.map((p) => p.getName()).filter((name) => perArm.every((set) => set.has(name))));
+    const required = props.map((p) => p.getName()).filter((n) => requiredInAll.has(n));
+    if (required.length)
       resolved.required = required;
     else
       delete resolved.required;
+    const emitted = new Set(Object.keys(resolved.properties));
+    const anyOf = perArmRequired(perArm, requiredInAll, emitted);
+    if (anyOf)
+      resolved.anyOf = anyOf;
   }
   resolved["x-ts-type"] = renderTypeText(type, checker, decl);
   return resolved;
 }
+function perArmRequired(perArm, shared, emitted) {
+  const distinct = new Map;
+  for (const set of perArm) {
+    const extra = [...set].filter((name) => emitted.has(name) && !shared.has(name));
+    if (extra.length === 0)
+      return;
+    distinct.set(extra.join("\x00"), extra);
+  }
+  if (distinct.size < 2)
+    return;
+  return [...distinct.values()].map((required) => ({ required }));
+}
 function annotateBindingElements(pattern, param, jsdocTags) {
   const schema = param.schema;
   const properties = schema?.properties;
@@ -5457,14 +5499,23 @@ function schemaFromTypeNode(node, ctx) {
 }
 function parametersFromAst(decl, ctx) {
   const jsdocTags = ts11.getJSDocTags(decl);
+  const taken = new Set(decl.parameters.flatMap((p) => ts11.isIdentifier(p.name) ? [p.name.text] : []));
   return decl.parameters.map((p) => {
-    const name = ts11.isIdentifier(p.name) ? p.name.text : p.name.getText();
+    const pattern = bindingPatternKind(p);
+    let name;
+    if (pattern) {
+      name = destructuredParamName(pattern, taken);
+      taken.add(name);
+    } else {
+      name = ts11.isIdentifier(p.name) ? p.name.text : p.name.getText();
+    }
     const isOptional = !!p.questionToken || !!p.initializer;
     const param = {
       name,
       schema: schemaFromTypeNode(p.type, ctx),
       required: !isOptional && !p.dotDotDotToken,
-      ...p.dotDotDotToken ? { rest: true } : {}
+      ...p.dotDotDotToken ? { rest: true } : {},
+      ...pattern ? { "x-ts-destructured": true } : {}
     };
     const description = getParamDescription(name, jsdocTags);
     if (description)
@@ -6159,544 +6210,6 @@ function serializeValue(name, node, symbol, jsdocNode, type, typeNode, ctx) {
   };
 }
 
-// src/types/schema-normalizer.ts
-import { JSON_SCHEMA_DRAFT } from "@openpkg-ts/spec";
-var TS_PRIMITIVE_NORMALIZATIONS = {
-  void: () => ({ type: "null", "x-ts-type": "void" }),
-  never: () => ({ not: {} }),
-  any: () => ({ "x-ts-type": "any" }),
-  unknown: () => ({ "x-ts-type": "unknown" }),
-  undefined: () => ({ type: "null", "x-ts-type": "undefined" }),
-  bigint: () => ({ type: "integer", "x-ts-type": "bigint" }),
-  symbol: () => ({ type: "string", "x-ts-type": "symbol" })
-};
-function normalizeSchema(schema, options = {}) {
-  const { includeSchemaField = false } = options;
-  const normalized = normalizeSchemaInternal(schema, options);
-  if (includeSchemaField && typeof normalized === "object") {
-    return {
-      $schema: JSON_SCHEMA_DRAFT,
-      ...normalized
-    };
-  }
-  return normalized;
-}
-function normalizeSchemaInternal(schema, options) {
-  const result = normalizeSchemaDispatch(schema, options);
-  if (schema && typeof schema === "object" && !Array.isArray(schema)) {
-    const s = schema;
-    if (s.deprecated === true && result.deprecated === undefined) {
-      result.deprecated = true;
-    }
-    if (s.readOnly === true && result.readOnly === undefined) {
-      result.readOnly = true;
-    }
-    for (const key of Object.keys(s)) {
-      if (key.startsWith("x-") && s[key] !== undefined && result[key] === undefined) {
-        result[key] = s[key];
-      }
-    }
-    if (Array.isArray(s.typeArguments) && s.typeArguments.length > 0 && result["x-ts-type-arguments"] === undefined) {
-      result["x-ts-type-arguments"] = s.typeArguments.map((arg) => normalizeSchemaInternal(arg, options));
-    }
-  }
-  return result;
-}
-function normalizeSchemaDispatch(schema, options) {
-  if (typeof schema === "string") {
-    return normalizeStringType(schema);
-  }
-  if (schema == null) {
-    return {};
-  }
-  if (typeof schema !== "object") {
-    return {};
-  }
-  if ("anyOf" in schema && Array.isArray(schema.anyOf)) {
-    return normalizeCombinator("anyOf", schema.anyOf, schema, options);
-  }
-  if ("allOf" in schema && Array.isArray(schema.allOf)) {
-    return normalizeCombinator("allOf", schema.allOf, schema, options);
-  }
-  if ("oneOf" in schema && Array.isArray(schema.oneOf)) {
-    return normalizeCombinator("oneOf", schema.oneOf, schema, options);
-  }
-  if ("$ref" in schema && typeof schema.$ref === "string") {
-    return normalizeRef(schema, options);
-  }
-  if ("type" in schema && typeof schema.type === "string") {
-    return normalizeTypedSchema(schema, options);
-  }
-  return normalizeGenericObject(schema, options);
-}
-function normalizeStringType(type) {
-  const specialNormalization = TS_PRIMITIVE_NORMALIZATIONS[type];
-  if (specialNormalization) {
-    return specialNormalization();
-  }
-  if (["string", "number", "boolean", "integer", "null", "object", "array"].includes(type)) {
-    return { type };
-  }
-  return { "x-ts-type": type };
-}
-function normalizeTypedSchema(schema, options) {
-  const { type } = schema;
-  const specialNormalization = TS_PRIMITIVE_NORMALIZATIONS[type];
-  if (specialNormalization) {
-    const normalized = specialNormalization();
-    return mergeSchemaFields(normalized, schema, ["type"]);
-  }
-  if (type === "function") {
-    return normalizeFunctionType(schema, options);
-  }
-  if (type === "tuple") {
-    return normalizeTupleType(schema, options);
-  }
-  if (type === "array") {
-    return normalizeArrayType(schema, options);
-  }
-  if (type === "object") {
-    return normalizeObjectType(schema, options);
-  }
-  if (["string", "number", "boolean", "integer", "null"].includes(type)) {
-    return normalizeStandardType(schema, options);
-  }
-  const result = { "x-ts-type": type };
-  return mergeSchemaFields(result, schema, ["type"]);
-}
-function normalizeFunctionType(schema, options) {
-  const result = {
-    "x-ts-function": true
-  };
-  if ("signatures" in schema && Array.isArray(schema.signatures)) {
-    result["x-ts-signatures"] = schema.signatures.map((sig) => normalizeSignature(sig, options));
-  }
-  if ("description" in schema && schema.description) {
-    result.description = schema.description;
-  }
-  return result;
-}
-function normalizeSignature(signature, options) {
-  const result = {};
-  if (signature.parameters) {
-    result.parameters = signature.parameters.map((param) => ({
-      name: param.name,
-      schema: normalizeSchemaInternal(param.schema, options),
-      ...param.required !== undefined ? { required: param.required } : {},
-      ...param.description ? { description: param.description } : {},
-      ...param.default !== undefined ? { default: param.default } : {},
-      ...param.rest ? { rest: param.rest } : {},
-      ...param["x-ts-destructured"] ? { "x-ts-destructured": true } : {}
-    }));
-  }
-  if (signature.returns) {
-    result.returns = {
-      schema: normalizeSchemaInternal(signature.returns.schema, options),
-      ...signature.returns.description ? { description: signature.returns.description } : {}
-    };
-  }
-  if (signature.description) {
-    result.description = signature.description;
-  }
-  if (signature.typeParameters) {
-    result.typeParameters = signature.typeParameters;
-  }
-  return result;
-}
-function normalizeTupleType(schema, options) {
-  const result = { type: "array" };
-  const prefix = Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.prefixedItems) ? schema.prefixedItems : undefined;
-  if (prefix) {
-    result.prefixItems = prefix.map((item) => normalizeSchemaInternal(item, options));
-  } else if ("items" in schema && Array.isArray(schema.items)) {
-    result.prefixItems = schema.items.map((item) => normalizeSchemaInternal(item, options));
-    result.minItems = schema.items.length;
-    result.maxItems = schema.items.length;
-  }
-  if ("minItems" in schema && typeof schema.minItems === "number") {
-    result.minItems = schema.minItems;
-  }
-  if ("maxItems" in schema && typeof schema.maxItems === "number") {
-    result.maxItems = schema.maxItems;
-  }
-  if ("description" in schema && schema.description) {
-    result.description = schema.description;
-  }
-  return result;
-}
-function normalizeArrayType(schema, options) {
-  const result = { type: "array" };
-  if ("items" in schema && schema.items && !Array.isArray(schema.items)) {
-    result.items = normalizeSchemaInternal(schema.items, options);
-  }
-  const arrayPrefix = Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.prefixedItems) ? schema.prefixedItems : undefined;
-  if (arrayPrefix) {
-    result.prefixItems = arrayPrefix.map((item) => normalizeSchemaInternal(item, options));
-  }
-  if ("minItems" in schema && typeof schema.minItems === "number") {
-    result.minItems = schema.minItems;
-  }
-  if ("maxItems" in schema && typeof schema.maxItems === "number") {
-    result.maxItems = schema.maxItems;
-  }
-  if (schema.uniqueItems === true) {
-    result.uniqueItems = true;
-  }
-  if (schema.contains && typeof schema.contains === "object") {
-    result.contains = normalizeSchemaInternal(schema.contains, options);
-  }
-  for (const keyword of ["title", "default"]) {
-    if (keyword in schema && schema[keyword] !== undefined) {
-      result[keyword] = schema[keyword];
-    }
-  }
-  if ("description" in schema && schema.description) {
-    result.description = schema.description;
-  }
-  return result;
-}
-function normalizeObjectType(schema, options) {
-  const result = { type: "object" };
-  if ("properties" in schema && schema.properties) {
-    const properties = schema.properties;
-    result.properties = Object.fromEntries(Object.entries(properties).map(([key, value]) => [
-      key,
-      normalizeSchemaInternal(value, options)
-    ]));
-  }
-  if ("required" in schema && Array.isArray(schema.required)) {
-    result.required = schema.required;
-  }
-  if ("additionalProperties" in schema) {
-    if (typeof schema.additionalProperties === "boolean") {
-      result.additionalProperties = schema.additionalProperties;
-    } else if (schema.additionalProperties) {
-      result.additionalProperties = normalizeSchemaInternal(schema.additionalProperties, options);
-    }
-  }
-  for (const keyword of ["patternProperties", "$defs"]) {
-    const value = schema[keyword];
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-      result[keyword] = Object.fromEntries(Object.entries(value).map(([key, nested]) => [
-        key,
-        normalizeSchemaInternal(nested, options)
-      ]));
-    }
-  }
-  if (schema.propertyNames && typeof schema.propertyNames === "object") {
-    result.propertyNames = normalizeSchemaInternal(schema.propertyNames, options);
-  }
-  for (const keyword of ["title", "default", "examples", "minProperties", "maxProperties"]) {
-    if (keyword in schema && schema[keyword] !== undefined) {
-      result[keyword] = schema[keyword];
-    }
-  }
-  if ("description" in schema && schema.description) {
-    result.description = schema.description;
-  }
-  return result;
-}
-function normalizeStandardType(schema, options) {
-  const result = { type: schema.type };
-  const validationKeywords = [
-    "enum",
-    "const",
-    "format",
-    "pattern",
-    "minimum",
-    "maximum",
-    "exclusiveMinimum",
-    "exclusiveMaximum",
-    "multipleOf",
-    "minLength",
-    "maxLength",
-    "description",
-    "default",
-    "examples",
-    "title"
-  ];
-  for (const keyword of validationKeywords) {
-    if (keyword in schema && schema[keyword] !== undefined) {
-      result[keyword] = schema[keyword];
-    }
-  }
-  for (const key of Object.keys(schema)) {
-    if (key.startsWith("x-") && schema[key] !== undefined) {
-      const value = schema[key];
-      if (isSchemaLike(value)) {
-        result[key] = normalizeSchemaInternal(value, options);
-      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        result[key] = normalizeGenericObject(value, options);
-      } else {
-        result[key] = value;
-      }
-    }
-  }
-  return result;
-}
-function normalizeRef(schema, options) {
-  const result = { $ref: schema.$ref };
-  if (schema.typeArguments && schema.typeArguments.length > 0) {
-    result["x-ts-type-arguments"] = schema.typeArguments.map((arg) => normalizeSchemaInternal(arg, options));
-  }
-  for (const key of Object.keys(schema)) {
-    if (key.startsWith("x-ts-") && schema[key] !== undefined) {
-      result[key] = schema[key];
-    }
-  }
-  return result;
-}
-function normalizeCombinator(keyword, schemas, originalSchema, options) {
-  let branches = schemas.map((s) => normalizeSchemaInternal(s, options));
-  if (keyword !== "allOf") {
-    const seen = new Set;
-    branches = branches.filter((b) => {
-      const key = JSON.stringify(b);
-      if (seen.has(key))
-        return false;
-      seen.add(key);
-      return true;
-    });
-    if (branches.length === 1) {
-      const single = { ...branches[0] };
-      if ("description" in originalSchema && originalSchema.description && !single.description) {
-        single.description = originalSchema.description;
-      }
-      return single;
-    }
-  }
-  const result = { [keyword]: branches };
-  if ((keyword === "anyOf" || keyword === "oneOf") && "discriminator" in originalSchema && originalSchema.discriminator) {
-    result.discriminator = originalSchema.discriminator;
-  }
-  if ("description" in originalSchema && originalSchema.description) {
-    result.description = originalSchema.description;
-  }
-  return result;
-}
-function normalizeGenericObject(schema, options) {
-  const result = {};
-  for (const [key, value] of Object.entries(schema)) {
-    if (value == null)
-      continue;
-    if (isSchemaLike(value)) {
-      result[key] = normalizeSchemaInternal(value, options);
-    } else if (Array.isArray(value)) {
-      result[key] = value.map((item) => isSchemaLike(item) ? normalizeSchemaInternal(item, options) : item);
-    } else if (typeof value === "object") {
-      result[key] = normalizeGenericObject(value, options);
-    } else {
-      result[key] = value;
-    }
-  }
-  return result;
-}
-function isSchemaLike(value) {
-  if (typeof value !== "object" || value == null)
-    return false;
-  if (typeof value === "string")
-    return true;
-  const obj = value;
-  return "type" in obj || "$ref" in obj || "anyOf" in obj || "allOf" in obj || "oneOf" in obj || "properties" in obj || "items" in obj || "prefixItems" in obj || "prefixedItems" in obj;
-}
-function mergeSchemaFields(target, source, excludeKeys) {
-  if (typeof source !== "object" || source == null) {
-    return target;
-  }
-  const excludeSet = new Set(excludeKeys);
-  const result = { ...target };
-  for (const [key, value] of Object.entries(source)) {
-    if (!excludeSet.has(key) && value !== undefined) {
-      if (!(key in result)) {
-        result[key] = value;
-      }
-    }
-  }
-  return result;
-}
-function isVendorSchemaExport(exp) {
-  return !!exp.tags?.some((t) => t.name === "schema-source" && t.text === "standard-json-schema");
-}
-function normalizeExport(exp, options = {}) {
-  const result = { ...exp };
-  const vendorSchema = isVendorSchemaExport(exp);
-  if (exp.schema && !vendorSchema) {
-    result.schema = normalizeSchema(exp.schema, options);
-  }
-  if (exp.signatures) {
-    result.signatures = exp.signatures.map((sig) => normalizeSignatureSpec(sig, options));
-  }
-  if (exp.members) {
-    result.members = exp.members.map((member) => normalizeMember(member, options));
-  }
-  if (!vendorSchema && shouldGenerateMembersSchema(exp.kind) && exp.members && exp.members.length > 0) {
-    result.schema = withOpenArms(normalizeMembers(exp.members, options), result.schema);
-  }
-  return result;
-}
-function withOpenArms(membersSchema, provided) {
-  const arms = provided?.allOf;
-  return Array.isArray(arms) ? { allOf: [membersSchema, ...arms] } : membersSchema;
-}
-function normalizeType(type, options = {}) {
-  const result = { ...type };
-  if (type.schema) {
-    result.schema = normalizeSchema(type.schema, options);
-  }
-  if (type.members) {
-    result.members = type.members.map((member) => normalizeMember(member, options));
-  }
-  if (shouldGenerateMembersSchema(type.kind) && type.members && type.members.length > 0) {
-    result.schema = withOpenArms(normalizeMembers(type.members, options), result.schema);
-  }
-  return result;
-}
-function shouldGenerateMembersSchema(kind) {
-  return kind === "interface" || kind === "class";
-}
-function normalizeSignatureSpec(signature, options) {
-  const result = { ...signature };
-  if (signature.parameters) {
-    result.parameters = signature.parameters.map((param) => ({
-      ...param,
-      schema: normalizeSchema(param.schema, options)
-    }));
-  }
-  if (signature.returns) {
-    result.returns = {
-      ...signature.returns,
-      schema: normalizeSchema(signature.returns.schema, options)
-    };
-  }
-  return result;
-}
-function normalizeMember(member, options) {
-  const result = { ...member };
-  if (member.schema) {
-    result.schema = normalizeSchema(member.schema, options);
-  }
-  if (member.signatures) {
-    result.signatures = member.signatures.map((sig) => normalizeSignatureSpec(sig, options));
-  }
-  return result;
-}
-function normalizeMembers(members, options = {}) {
-  const properties = {};
-  const required = [];
-  let additionalProperties;
-  let numberIndexSchema;
-  for (const member of members) {
-    const { name, kind } = member;
-    if (kind === "index" || kind === "index-signature") {
-      if (name === "[number]") {
-        numberIndexSchema = normalizeMemberToSchema(member, options);
-      } else {
-        additionalProperties = normalizeMemberToSchema(member, options);
-      }
-      continue;
-    }
-    if (!name)
-      continue;
-    const memberSchema = normalizeMemberToSchema(member, options);
-    properties[name] = memberSchema;
-    if (!isOptionalMember(member)) {
-      required.push(name);
-    }
-  }
-  const result = {
-    type: "object",
-    properties
-  };
-  if (required.length > 0) {
-    result.required = required;
-  }
-  if (additionalProperties !== undefined) {
-    result.additionalProperties = additionalProperties;
-  }
-  if (numberIndexSchema !== undefined) {
-    result.patternProperties = { "^\\d+$": numberIndexSchema };
-    result["x-ts-index-key"] = "number";
-  }
-  return result;
-}
-function memberDocExtras(member) {
-  const extras = {};
-  if (member.description) {
-    extras.description = member.description;
-  }
-  if (member.flags?.readonly === true) {
-    extras.readOnly = true;
-  }
-  if (member.deprecated) {
-    extras.deprecated = true;
-    const reason = member.deprecationReason ?? member.tags?.find((t) => t.name === "deprecated")?.text;
-    if (reason?.trim()) {
-      extras["x-deprecated-reason"] = reason;
-    }
-  }
-  return extras;
-}
-function normalizeMemberToSchema(member, options) {
-  const { kind, schema, signatures } = member;
-  if (kind === "method" || kind === "call-signature") {
-    return normalizeMethodMember(member, options);
-  }
-  if (kind === "getter") {
-    const baseSchema2 = schema ? normalizeSchemaInternal(schema, options) : {};
-    return {
-      ...baseSchema2,
-      "x-ts-accessor": "getter",
-      ...memberDocExtras(member)
-    };
-  }
-  if (kind === "setter") {
-    const baseSchema2 = schema ? normalizeSchemaInternal(schema, options) : {};
-    return {
-      ...baseSchema2,
-      "x-ts-accessor": "setter",
-      ...memberDocExtras(member)
-    };
-  }
-  if (kind === "index" || kind === "index-signature") {
-    if (schema && typeof schema === "object" && "additionalProperties" in schema) {
-      return normalizeSchemaInternal(schema.additionalProperties, options);
-    }
-    return schema ? normalizeSchemaInternal(schema, options) : {};
-  }
-  if (signatures && signatures.length > 0) {
-    return normalizeMethodMember(member, options);
-  }
-  const baseSchema = schema ? normalizeSchemaInternal(schema, options) : {};
-  const extras = memberDocExtras(member);
-  return Object.keys(extras).length > 0 ? { ...baseSchema, ...extras } : baseSchema;
-}
-function normalizeMethodMember(member, options) {
-  const result = {
-    "x-ts-function": true
-  };
-  if (member.flags?.methodSyntax === true) {
-    result["x-ts-method"] = true;
-  }
-  const memberTypeText = member.schema && typeof member.schema === "object" ? member.schema["x-ts-type"] : undefined;
-  if (typeof memberTypeText === "string") {
-    result["x-ts-type"] = memberTypeText;
-  }
-  if (member.signatures && member.signatures.length > 0) {
-    result["x-ts-signatures"] = member.signatures.map((sig) => normalizeSignature(sig, options));
-  }
-  Object.assign(result, memberDocExtras(member));
-  return result;
-}
-function isOptionalMember(member) {
-  if (member.flags?.optional === true) {
-    return true;
-  }
-  if (member.name?.endsWith("?")) {
-    return true;
-  }
-  return false;
-}
-
 // src/primitives/get.ts
 async function getExport(options) {
   const { entryFile, exportName, baseDir, content, maxTypeDepth } = options;
@@ -9063,7 +8576,7 @@ import {
   validateSpec as validateSpec2
 } from "@openpkg-ts/spec";
 // src/schema/json-schema.ts
-import { JSON_SCHEMA_DRAFT as JSON_SCHEMA_DRAFT2 } from "@openpkg-ts/spec";
+import { JSON_SCHEMA_DRAFT } from "@openpkg-ts/spec";
 
 // src/schema/ref-walker.ts
 var INTERNAL_REF_PREFIX = "#/types/";
@@ -9199,7 +8712,7 @@ function exportToJsonSchema(subject, spec, options = {}) {
   if (Object.keys(defs).length > 0)
     doc.$defs = defs;
   if (includeSchemaField)
-    return { $schema: JSON_SCHEMA_DRAFT2, ...doc };
+    return { $schema: JSON_SCHEMA_DRAFT, ...doc };
   return doc;
 }
 function toJsonSchema(spec, options = {}) {
@@ -9236,7 +8749,7 @@ function toJsonSchema(spec, options = {}) {
   }
   const doc = { $defs: defs };
   if (includeSchemaField)
-    return { $schema: JSON_SCHEMA_DRAFT2, ...doc };
+    return { $schema: JSON_SCHEMA_DRAFT, ...doc };
   return doc;
 }
 
@@ -9611,6 +9124,7 @@ export {
   isSymbolDeprecated,
   isStandardJSONSchema,
   isSchemaType,
+  isRequiredOnlyAnyOf,
   isRemoteInput,
   isReadonlyPropertySymbol,
   isPureRefSchema,