@lupinum/ginko-content 0.3.3 → 0.3.5

package/dist/cms-contract/build.js

@@ -84,20 +84,20 @@ function fieldFromSchema(key, schema, localized) {
   const required = !["ZodOptional", "ZodNullable", "ZodDefault"].includes(getSchemaTypeName(schema) ?? "");
   if (metadata) return fieldFromMetadata(key, metadata, schema, unwrapped, localized, required);
   const reference = getReferenceDescriptor(unwrapped);
-  if (reference) return field({ key, type: "relation", required, default: defaultFromSchema(schema), relation: { collection: reference.collection ?? "", multiple: false } });
+  if (reference) return field({ key, type: "relation", required, default: defaultFromSchema(schema, key), relation: { collection: reference.collection ?? "", multiple: false } });
   const typeName = getSchemaTypeName(unwrapped);
-  if (typeName === "ZodObject") return field({ key, type: "object", required, localized, default: defaultFromSchema(schema), fields: nestedFields(unwrapped), validation: validationFromSchema(schema) });
+  if (typeName === "ZodObject") return field({ key, type: "object", required, localized, default: defaultFromSchema(schema, key), fields: nestedFields(unwrapped), validation: validationFromSchema(schema) });
   if (typeName === "ZodArray") {
     const element = getSchemaDef(unwrapped)?.element;
     const relation = getReferenceDescriptor(unwrapSchema(element));
-    if (relation) return field({ key, type: "relations", required, default: defaultFromSchema(schema), relation: { collection: relation.collection ?? "", multiple: true } });
+    if (relation) return field({ key, type: "relations", required, default: defaultFromSchema(schema, key), relation: { collection: relation.collection ?? "", multiple: true } });
     const children = getSchemaTypeName(unwrapSchema(element)) === "ZodObject" ? nestedFields(element) : null;
-    return field({ key, type: children ? "array" : "json", required, localized, default: defaultFromSchema(schema), fields: children, validation: validationFromSchema(schema) });
+    return field({ key, type: children ? "array" : "json", required, localized, default: defaultFromSchema(schema, key), fields: children, validation: validationFromSchema(schema) });
   }
-  if (typeName === "ZodNumber") return field({ key, type: "number", required, default: defaultFromSchema(schema), validation: validationFromSchema(schema) });
-  if (typeName === "ZodBoolean") return field({ key, type: "toggle", required, default: defaultFromSchema(schema), validation: validationFromSchema(schema) });
-  if (typeName === "ZodDate") return field({ key, type: "date", required, default: defaultFromSchema(schema), validation: validationFromSchema(schema) });
-  return field({ key, type: typeName === "ZodString" ? "text" : "json", required, localized, default: defaultFromSchema(schema), validation: validationFromSchema(schema) });
+  if (typeName === "ZodNumber") return field({ key, type: "number", required, default: defaultFromSchema(schema, key), validation: validationFromSchema(schema) });
+  if (typeName === "ZodBoolean") return field({ key, type: "toggle", required, default: defaultFromSchema(schema, key), validation: validationFromSchema(schema) });
+  if (typeName === "ZodDate") return field({ key, type: "date", required, default: defaultFromSchema(schema, key), validation: validationFromSchema(schema) });
+  return field({ key, type: typeName === "ZodString" ? "text" : "json", required, localized, default: defaultFromSchema(schema, key), validation: validationFromSchema(schema) });
 }
 function fieldFromMetadata(key, metadata, sourceSchema, schema, localized, required) {
   const type = metadata.type === "boolean" ? "toggle" : metadata.type === "asset" ? "file" : metadata.type;
@@ -107,7 +107,7 @@ function fieldFromMetadata(key, metadata, sourceSchema, schema, localized, requi
     type,
     required: metadata.required ?? required,
     localized: metadata.localized ?? localized,
-    default: defaultFromSchema(sourceSchema),
+    default: defaultFromSchema(sourceSchema, key),
     options: metadata.options ?? null,
     relation: metadata.relation ? { collection: metadata.relation.collectionId, multiple: metadata.relation.multiple ?? type === "relations" } : null,
     media: metadata.image || metadata.asset ? { mediaTypes: portableMediaTypes(metadata.image?.accept ?? metadata.asset?.accept), aspectRatio: metadata.image?.aspectRatio ?? null } : null,
@@ -132,7 +132,7 @@ function mergeField(existing, key, override, localized) {
     localized: override.localized ?? base.localized,
     searchable: override.searchable ?? base.searchable,
     sortable: override.sortable ?? base.sortable,
-    default: Object.prototype.hasOwnProperty.call(override, "defaultValue") ? { present: true, value: override.defaultValue } : base.default,
+    default: Object.prototype.hasOwnProperty.call(override, "defaultValue") ? { present: true, value: jsonDefault(override.defaultValue, key) } : base.default,
     options: override.options ?? base.options,
     relation: override.relation ? { collection: override.relation.collectionId, multiple: override.relation.multiple ?? type === "relations" } : base.relation,
     fields: override.fields ? configuredFields(override.fields, false) : base.fields,
@@ -143,17 +143,45 @@ function mergeField(existing, key, override, localized) {
     language: override.language ?? base.language
   });
 }
-function defaultFromSchema(schema) {
+function defaultFromSchema(schema, key) {
   let current = schema;
   while (current) {
     const typeName = getSchemaTypeName(current);
     const definition = getSchemaDef(current);
-    if (typeName === "ZodDefault") return { present: true, value: definition?.defaultValue };
+    if (typeName === "ZodDefault") return { present: true, value: jsonDefault(definition?.defaultValue, key) };
     if (!["ZodOptional", "ZodNullable"].includes(typeName ?? "")) break;
     current = definition?.innerType;
   }
   return { present: false };
 }
+function jsonDefault(value, key, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError(`Field "${key}" has a non-finite default value.`);
+    return value;
+  }
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) throw new TypeError(`Field "${key}" has an invalid date default.`);
+    return value.toISOString();
+  }
+  if (typeof value !== "object" || value === null) throw new TypeError(`Field "${key}" has a non-JSON-serializable default value.`);
+  if (ancestors.has(value)) throw new TypeError(`Field "${key}" has a cyclic default value.`);
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) return value.map((entry, index) => jsonDefault(entry, `${key}[${index}]`, ancestors));
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) throw new TypeError(`Field "${key}" has a non-JSON-serializable default value.`);
+    if (Object.getOwnPropertySymbols(value).length > 0) throw new TypeError(`Field "${key}" has a non-JSON-serializable default value.`);
+    const result = {};
+    for (const [property, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+      if (!descriptor.enumerable || !("value" in descriptor)) throw new TypeError(`Field "${key}" has a non-JSON-serializable default value.`);
+      result[property] = jsonDefault(descriptor.value, `${key}.${property}`, ancestors);
+    }
+    return result;
+  } finally {
+    ancestors.delete(value);
+  }
+}
 function validationFromSchema(schema, semanticType) {
   const typeName = getSchemaTypeName(schema);
   const definition = getSchemaDef(schema);
@@ -170,16 +198,16 @@ function validationFromSchema(schema, semanticType) {
     const format = ["email", "url", "date", "datetime", "time"].includes(String(value.format)) ? value.format : null;
     return {
       kind: "string",
-      minLength: typeof value.minLength === "number" ? value.minLength : null,
-      maxLength: typeof value.maxLength === "number" ? value.maxLength : null,
+      minLength: finiteNumber(value.minLength),
+      maxLength: finiteNumber(value.maxLength),
       format
     };
   }
   if (typeName === "ZodNumber") {
     return {
       kind: "number",
-      min: typeof value.minValue === "number" ? value.minValue : null,
-      max: typeof value.maxValue === "number" ? value.maxValue : null,
+      min: finiteNumber(value.minValue),
+      max: finiteNumber(value.maxValue),
       integer: value.isInt === true
     };
   }
@@ -210,12 +238,17 @@ function arrayLimits(checks) {
   if (Array.isArray(checks)) {
     for (const check of checks) {
       const definition = check._zod?.def ?? check.def;
-      if (definition?.check === "min_length" && typeof definition.minimum === "number") minItems = definition.minimum;
-      if (definition?.check === "max_length" && typeof definition.maximum === "number") maxItems = definition.maximum;
+      const minimum = finiteNumber(definition?.minimum);
+      const maximum = finiteNumber(definition?.maximum);
+      if (definition?.check === "min_length" && minimum !== null) minItems = minimum;
+      if (definition?.check === "max_length" && maximum !== null) maxItems = maximum;
     }
   }
   return { minItems, maxItems };
 }
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
 function configuredFields(input, localized) {
   const entries = Array.isArray(input) ? input.map((value, index) => [String(index), value]) : Object.entries(input);
   return entries.flatMap(([key, value]) => value.type === "divider" || value.type === "section" ? [] : [mergeField(void 0, key, value, localized)]);

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@lupinum/ginko-content",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "configKey": "content",
   "compatibility": {
     "nuxt": ">=4.4.7 <5"

package/dist/module.mjs

@@ -30,7 +30,7 @@ import { createRouterMatcher } from 'vue-router';
 import { globby } from 'globby';
 
 const name = "@lupinum/ginko-content";
-const version = "0.3.3";
+const version = "0.3.5";
 const peerDependencies = {
 	nuxt: ">=4.4.7 <5"};
 

package/dist/runtime/app/components/ContentRendererInline.vue

@@ -4,7 +4,7 @@ import { computed, onServerPrefetch, shallowRef, useAttrs, watch } from "vue";
 import { useRuntimeConfig, useState } from "#imports";
 import MarkdownRenderer from "./internal/MarkdownRenderer.js";
 import { useUnwrap } from "../composables/useUnwrap";
-import { resolveMarkdownPlugins, resolveMarkdownRendererComponents } from "../../markdown/plugins";
+import { resolveMarkdownPlugins, resolveMarkdownRendererComponents, resolveMarkdownRendererFallbackComponents } from "../../markdown/plugins";
 import { toMarkdownRoot } from "../../../core/markdown/tree";
 import { parseComark } from "../../../core/markdown/parse-comark";
 import { loadContentComponentEntries } from "../../../integrations/vue/content-components";
@@ -44,6 +44,7 @@ const initialState = useState(stateKey, () => ({
   tree: null
 }));
 const tree = shallowRef(initialState.value.tree);
+const fallbackComponents = resolveMarkdownRendererFallbackComponents();
 const resolvedComponents = computed(() => ({
   ...Object.fromEntries(loadContentComponentEntries({
     type: "root",
@@ -92,6 +93,7 @@ watch(
     :tag="tag"
     :prose="prose"
     :components="resolvedComponents"
+    :fallback-components="fallbackComponents"
     v-bind="rendererAttrs"
   />
 </template>

package/dist/runtime/app/components/internal/ContentRendererMarkdown.vue

@@ -7,7 +7,7 @@ import MarkdownRenderer from "./MarkdownRenderer.js";
 import { useLocalePath } from "../../composables/content-i18n";
 import { resolveMarkdownRenderRefs, rewriteMarkdownRefLinks } from "../../../../core/references/resolve";
 import { loadContentComponentEntries } from "../../../../integrations/vue/content-components";
-import { resolveMarkdownRendererComponents } from "../../../markdown/plugins";
+import { resolveMarkdownRendererComponents, resolveMarkdownRendererFallbackComponents } from "../../../markdown/plugins";
 import { isMarkdownRoot } from "../../../../core/markdown/tree";
 const props = defineProps({
   value: {
@@ -79,6 +79,7 @@ const renderedBody = computed(() => {
   }
   return props.unwrap ? unwrapRoot(body.value, props.unwrap) : body.value;
 });
+const fallbackComponents = resolveMarkdownRendererFallbackComponents();
 const resolvedComponents = computed(() => {
   if (!renderedBody.value) {
     return props.components;
@@ -108,6 +109,7 @@ const rendererAttrs = computed(() => {
     :default-locale="defaultLocale"
     :locales="locales"
     :components="resolvedComponents"
+    :fallback-components="fallbackComponents"
     :render-policy="renderPolicy"
     :data-content-id="debug ? value.id : void 0"
     v-bind="rendererAttrs"

package/dist/runtime/app/components/internal/MarkdownRenderer.d.ts

@@ -11,6 +11,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<Record<string, any>>;
         default: () => {};
     };
+    fallbackComponents: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
     prose: {
         type: PropType<boolean | undefined>;
         default: undefined;
@@ -56,6 +60,10 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: PropType<Record<string, any>>;
         default: () => {};
     };
+    fallbackComponents: {
+        type: PropType<Record<string, any>>;
+        default: () => {};
+    };
     prose: {
         type: PropType<boolean | undefined>;
         default: undefined;
@@ -97,6 +105,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
     components: Record<string, any>;
     tag: string;
     class: string | unknown[] | Record<string, any>;
+    fallbackComponents: Record<string, any>;
     prose: boolean | undefined;
     dataContentId: string;
     renderPolicy: PortableComponentPolicyV1;

package/dist/runtime/app/components/internal/MarkdownRenderer.js

@@ -23,7 +23,7 @@ export function localizeMarkdownNodeProps(props, locale, defaultLocale, locales
   localizeLinkProps(localizedProps, locale, defaultLocale, locales);
   return localizedProps;
 }
-function resolveVueComponent(name, components, registry, prose, seen = /* @__PURE__ */ new Set()) {
+function resolveVueComponent(name, components, registry, fallbacks, prose, seen = /* @__PURE__ */ new Set()) {
   if (seen.has(name)) {
     return null;
   }
@@ -40,7 +40,7 @@ function resolveVueComponent(name, components, registry, prose, seen = /* @__PUR
     const explicit = components[candidate];
     if (explicit) {
       if (typeof explicit === "string" && explicit !== candidate && !htmlTags.includes(explicit)) {
-        return resolveVueComponent(explicit, components, registry, prose, seen) || explicit;
+        return resolveVueComponent(explicit, components, registry, fallbacks, prose, seen) || explicit;
       }
       return explicit;
     }
@@ -51,6 +51,12 @@ function resolveVueComponent(name, components, registry, prose, seen = /* @__PUR
       return registered;
     }
   }
+  for (const candidate of candidates) {
+    const fallback = fallbacks[candidate];
+    if (fallback) {
+      return fallback;
+    }
+  }
   return null;
 }
 function renderNode(node, options, key, parent) {
@@ -72,8 +78,8 @@ function renderNode(node, options, key, parent) {
   if (parent?.tag === "pre") {
     component = tag;
   } else {
-    const resolvedAs = typeof nodeProps.as === "string" ? resolveVueComponent(nodeProps.as, options.components, options.registry, options.prose) : null;
-    const resolvedComponent = resolvedAs || resolveVueComponent(tag, options.components, options.registry, options.prose);
+    const resolvedAs = typeof nodeProps.as === "string" ? resolveVueComponent(nodeProps.as, options.components, options.registry, options.fallbacks, options.prose) : null;
+    const resolvedComponent = resolvedAs || resolveVueComponent(tag, options.components, options.registry, options.fallbacks, options.prose);
     if (resolvedComponent) {
       component = resolvedComponent;
     } else if (htmlTags.includes(tag)) {
@@ -143,6 +149,10 @@ export default defineComponent({
       type: Object,
       default: () => ({})
     },
+    fallbackComponents: {
+      type: Object,
+      default: () => ({})
+    },
     prose: {
       type: Boolean,
       default: void 0
@@ -184,6 +194,7 @@ export default defineComponent({
       const children = (props.tree.children || []).map((node, index) => renderNode(node, {
         components: props.components,
         registry,
+        fallbacks: props.fallbackComponents,
         prose: props.prose,
         locale: props.locale,
         defaultLocale: props.defaultLocale,

package/dist/runtime/markdown/plugins.d.ts

@@ -1,3 +1,8 @@
 import type { ResolvedMarkdownPlugin } from '../../types/content';
 export { resolveMarkdownPlugins } from '../../parsers/markdown-plugins';
+/**
+ * Builtin prose components resolve after the app's component registry, so an
+ * app-registered ProseImg (or a tags remap) wins over the bundled default.
+ */
+export declare function resolveMarkdownRendererFallbackComponents(): Record<string, unknown>;
 export declare function resolveMarkdownRendererComponents(plugins: ResolvedMarkdownPlugin[]): Record<string, unknown>;

package/dist/runtime/markdown/plugins.js

@@ -23,10 +23,11 @@ const builtinMarkdownPlugins = {
 const builtinMarkdownComponents = {
   ProseImg: defineAsyncComponent(async () => await import("../app/components/Prose/ProseImg.vue"))
 };
+export function resolveMarkdownRendererFallbackComponents() {
+  return { ...builtinMarkdownComponents };
+}
 export function resolveMarkdownRendererComponents(plugins) {
-  const components = {
-    ...builtinMarkdownComponents
-  };
+  const components = {};
   for (const plugin of plugins) {
     const builtin = builtinMarkdownPlugins[plugin.name];
     if (builtin?.componentName && builtin.component) {

package/dist/web-types.json

@@ -1,7 +1,7 @@
 {
   "framework": "vue",
   "name": "@lupinum/ginko-content",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "contributions": {
     "html": {
       "description-markup": "markdown",
@@ -202,6 +202,14 @@
               },
               "default": "() => ({})"
             },
+            {
+              "name": "fallbackComponents",
+              "value": {
+                "kind": "expression",
+                "type": "Record<string, any>"
+              },
+              "default": "() => ({})"
+            },
             {
               "name": "prose",
               "value": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lupinum/ginko-content",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "description": "Collection-first content engine for Nuxt",
   "homepage": "https://github.com/lupinum-dev/ginko-content",
   "bugs": {