radiant-docs 0.1.64 → 0.1.65

package/template/src/lib/openapi/schema-variant-labels.ts

@@ -0,0 +1,213 @@
+type ObjectPropertiesResolver = (schema: any) => Record<string, any>;
+type TypeLabelResolver = (schema: any) => string;
+
+interface SchemaVariantLabelOptions {
+  parentSchema?: any;
+  siblings?: any[];
+  getObjectProperties?: ObjectPropertiesResolver;
+  getTypeLabel?: TypeLabelResolver;
+}
+
+function getSchemaVariants(schema: any): any[] {
+  if (!schema) return [];
+  if (Array.isArray(schema.oneOf)) return schema.oneOf;
+  if (Array.isArray(schema.anyOf)) return schema.anyOf;
+  return [];
+}
+
+function isNullSchema(schema: any): boolean {
+  if (!schema || typeof schema !== "object") return false;
+  if (schema.type === "null") return true;
+  return Array.isArray(schema.type) && schema.type.includes("null");
+}
+
+function unwrapNullableSchema(schema: any, seen = new Set<any>()): any {
+  if (!schema || typeof schema !== "object") return schema;
+  if (seen.has(schema)) return schema;
+
+  const nextSeen = new Set(seen);
+  nextSeen.add(schema);
+
+  if (Array.isArray(schema.type) && schema.type.includes("null")) {
+    const nonNullTypes = schema.type.filter((type: string) => type !== "null");
+    if (nonNullTypes.length === 1) {
+      return unwrapNullableSchema(
+        {
+          ...schema,
+          type: nonNullTypes[0],
+        },
+        nextSeen,
+      );
+    }
+  }
+
+  const variants = getSchemaVariants(schema);
+  const nonNullVariants = variants.filter((variant) => !isNullSchema(variant));
+  if (nonNullVariants.length === 1 && nonNullVariants.length < variants.length) {
+    return unwrapNullableSchema(nonNullVariants[0], nextSeen);
+  }
+
+  return schema;
+}
+
+function getSchemaRefName(schema: any): string | undefined {
+  if (typeof schema?.$ref !== "string" || !schema.$ref.trim()) {
+    return undefined;
+  }
+
+  const refParts = schema.$ref.split("/");
+  const refName = refParts[refParts.length - 1]?.trim();
+  if (!refName) return undefined;
+
+  try {
+    return decodeURIComponent(refName);
+  } catch {
+    return refName;
+  }
+}
+
+function getSingleLiteralValue(schema: any): string | undefined {
+  const renderSchema = unwrapNullableSchema(schema);
+  if (!renderSchema || typeof renderSchema !== "object") return undefined;
+
+  const constValue = renderSchema.const;
+  if (
+    typeof constValue === "string" ||
+    typeof constValue === "number" ||
+    typeof constValue === "boolean"
+  ) {
+    return String(constValue);
+  }
+
+  if (Array.isArray(renderSchema.enum) && renderSchema.enum.length === 1) {
+    const [enumValue] = renderSchema.enum;
+    if (
+      typeof enumValue === "string" ||
+      typeof enumValue === "number" ||
+      typeof enumValue === "boolean"
+    ) {
+      return String(enumValue);
+    }
+  }
+
+  return undefined;
+}
+
+function getDefaultObjectProperties(schema: any): Record<string, any> {
+  if (!schema || typeof schema !== "object") return {};
+
+  let properties: Record<string, any> = {};
+  if (schema.properties && typeof schema.properties === "object") {
+    properties = { ...properties, ...schema.properties };
+  }
+
+  if (Array.isArray(schema.allOf)) {
+    schema.allOf.forEach((part: any) => {
+      properties = { ...properties, ...getDefaultObjectProperties(part) };
+    });
+  }
+
+  return properties;
+}
+
+function getSingleLiteralPropertyLabels(
+  schema: any,
+  getObjectProperties: ObjectPropertiesResolver,
+): Record<string, string> {
+  return Object.fromEntries(
+    Object.entries(getObjectProperties(schema))
+      .map(([name, propertySchema]) => [
+        name,
+        getSingleLiteralValue(propertySchema),
+      ])
+      .filter((entry): entry is [string, string] => Boolean(entry[1])),
+  );
+}
+
+function getDiscriminatorVariantLabel(
+  schema: any,
+  parentSchema: any,
+  getObjectProperties: ObjectPropertiesResolver,
+): string | undefined {
+  const propertyName = parentSchema?.discriminator?.propertyName;
+  if (typeof propertyName !== "string" || !propertyName.trim()) {
+    return undefined;
+  }
+
+  return getSingleLiteralPropertyLabels(schema, getObjectProperties)[
+    propertyName
+  ];
+}
+
+function getUniqueLiteralVariantLabel(
+  schema: any,
+  siblings: any[],
+  getObjectProperties: ObjectPropertiesResolver,
+): string | undefined {
+  if (siblings.length < 2) return undefined;
+
+  const siblingLabels = siblings.map((variant) =>
+    getSingleLiteralPropertyLabels(variant, getObjectProperties),
+  );
+  const currentLabels = getSingleLiteralPropertyLabels(
+    schema,
+    getObjectProperties,
+  );
+  const preferredNames = ["type", "kind", "event", "object", "role"];
+  const propertyNames = Object.keys(currentLabels).sort((nameA, nameB) => {
+    const preferenceA = preferredNames.indexOf(nameA);
+    const preferenceB = preferredNames.indexOf(nameB);
+    if (preferenceA !== -1 || preferenceB !== -1) {
+      return (
+        (preferenceA === -1 ? Number.POSITIVE_INFINITY : preferenceA) -
+        (preferenceB === -1 ? Number.POSITIVE_INFINITY : preferenceB)
+      );
+    }
+    return nameA.localeCompare(nameB);
+  });
+
+  for (const propertyName of propertyNames) {
+    const labels = siblingLabels.map(
+      (labelsByName) => labelsByName[propertyName],
+    );
+    if (labels.some((label) => !label)) continue;
+    if (new Set(labels).size === siblings.length) {
+      return currentLabels[propertyName];
+    }
+  }
+
+  return undefined;
+}
+
+export function getSchemaVariantLabel(
+  schema: any,
+  index: number,
+  options: SchemaVariantLabelOptions = {},
+): string {
+  if (typeof schema?.title === "string" && schema.title.trim()) {
+    return schema.title.trim();
+  }
+
+  const refName = getSchemaRefName(schema);
+  if (refName) return refName;
+
+  const getObjectProperties =
+    options.getObjectProperties || getDefaultObjectProperties;
+  const discriminatorLabel = getDiscriminatorVariantLabel(
+    schema,
+    options.parentSchema,
+    getObjectProperties,
+  );
+  if (discriminatorLabel) return discriminatorLabel;
+
+  const uniqueLiteralLabel = getUniqueLiteralVariantLabel(
+    schema,
+    options.siblings || [],
+    getObjectProperties,
+  );
+  if (uniqueLiteralLabel) return uniqueLiteralLabel;
+
+  const typeLabel = options.getTypeLabel?.(schema);
+  if (typeLabel && typeLabel !== "unknown") return typeLabel;
+  return `Variant ${index + 1}`;
+}

package/template/.vscode/extensions.json

@@ -1,4 +0,0 @@
-{
-  "recommendations": ["astro-build.astro-vscode"],
-  "unwantedRecommendations": []
-}

package/template/.vscode/launch.json

@@ -1,11 +0,0 @@
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "command": "./node_modules/.bin/astro dev",
-      "name": "Development server",
-      "request": "launch",
-      "type": "node-terminal"
-    }
-  ]
-}