@lupinum/ginko-content 0.1.0

package/dist/integrations/nitro/storage.js

@@ -0,0 +1,113 @@
+import { prefixStorage } from "unstorage";
+import { useStorage } from "nitropack/runtime";
+import virtualContentConfig from "#content/virtual/config";
+import { makeIgnored } from "../../core/content/ignore";
+import { getContentRuntimeContext } from "./context.js";
+import { getPreview, isPreview } from "./preview.js";
+import { getContentRuntimeConfig } from "./runtime-config.js";
+const invalidKeyCharacters = ["'", '"', "?", "#", "/"];
+const createScopedStorage = (prefix) => prefixStorage(useStorage(), prefix);
+const getEventStorages = (event) => {
+  const runtime = getContentRuntimeContext(event);
+  runtime.storages ||= {
+    sourceStorage: createScopedStorage("content:source"),
+    cacheStorage: createScopedStorage("cache:content"),
+    cacheParsedStorage: createScopedStorage("cache:content:parsed")
+  };
+  return runtime.storages;
+};
+export const sourceStorage = (event) => {
+  if (event) {
+    return getEventStorages(event).sourceStorage;
+  }
+  return createScopedStorage("content:source");
+};
+export const cacheStorage = (event) => {
+  if (event) {
+    return getEventStorages(event).cacheStorage;
+  }
+  return createScopedStorage("cache:content");
+};
+export const cacheParsedStorage = (event) => {
+  if (event) {
+    return getEventStorages(event).cacheParsedStorage;
+  }
+  return createScopedStorage("cache:content:parsed");
+};
+const mergeCollectionConfigs = (runtimeCollections = {}, sourceCollections = {}) => {
+  const names = /* @__PURE__ */ new Set([
+    ...Object.keys(sourceCollections),
+    ...Object.keys(runtimeCollections)
+  ]);
+  return Object.fromEntries(Array.from(names).map((name) => {
+    const source = sourceCollections[name] || {};
+    const runtime = runtimeCollections[name] || {};
+    return [
+      name,
+      {
+        ...source,
+        ...runtime,
+        ...source.schema ? { schema: source.schema } : {},
+        ...source.providers ? { providers: source.providers } : {}
+      }
+    ];
+  }));
+};
+export const contentConfig = () => {
+  const runtimeContent = getContentRuntimeConfig().content;
+  const sourceContent = virtualContentConfig || {};
+  return {
+    ...runtimeContent,
+    collections: mergeCollectionConfigs(runtimeContent.collections, sourceContent.collections)
+  };
+};
+export const contentIgnorePredicate = (key) => {
+  const isIgnored = makeIgnored(contentConfig().ignores);
+  if (key.startsWith("preview:") || isIgnored(key)) {
+    return false;
+  }
+  if (invalidKeyCharacters.some((character) => key.includes(character))) {
+    console.warn(`Ignoring [${key}]. File name should not contain any of the following characters: ${invalidKeyCharacters.join(", ")}`);
+    return false;
+  }
+  return true;
+};
+export const getContentsIds = async (event, prefix) => {
+  let keys = [];
+  if (process.env.NODE_ENV === "production") {
+    keys = await cacheParsedStorage(event).getKeys(prefix);
+  }
+  const source = sourceStorage(event);
+  if (keys.length === 0) {
+    keys = await source.getKeys(prefix);
+  }
+  if (isPreview(event)) {
+    const { key } = getPreview(event);
+    const previewNamespace = `preview:${key}:`;
+    const previewPrefix = `${previewNamespace}${prefix || ""}`;
+    const previewKeys = await source.getKeys(previewPrefix);
+    if (previewKeys.length) {
+      const keysSet = new Set(keys);
+      await Promise.all(previewKeys.map(async (previewKey) => {
+        const normalizedPreviewKey = previewKey.startsWith(previewNamespace) ? previewKey.substring(previewNamespace.length) : previewKey;
+        const meta = await source.getMeta(previewKey);
+        if (meta?.__deleted) {
+          keysSet.delete(normalizedPreviewKey);
+        } else {
+          keysSet.add(normalizedPreviewKey);
+        }
+      }));
+      keys = Array.from(keysSet);
+    }
+  }
+  return keys.filter(contentIgnorePredicate);
+};
+export const resolveStorageId = async (event, id) => {
+  if (!isPreview(event)) {
+    return id;
+  }
+  const { key } = getPreview(event);
+  const previewId = `preview:${key}:${id}`;
+  const draft = await sourceStorage(event).getItem(previewId);
+  return draft ? previewId : id;
+};

package/dist/integrations/vue/content-components

@@ -0,0 +1 @@
+export * from './content-components.js'

package/dist/integrations/vue/content-components.d.ts

@@ -0,0 +1,24 @@
+import type { AsyncComponentLoader } from 'vue';
+type ContentBodyNode = {
+    type?: string;
+    tag?: string;
+    props?: Record<string, unknown>;
+    children?: ContentBodyNode[];
+};
+type Renderable = {
+    render?: (props: Record<string, unknown>) => unknown;
+    ssrRender?: (props: Record<string, unknown>) => unknown;
+};
+export interface ContentComponentCatalog {
+    globalComponents?: string[];
+    localComponents?: string[];
+    localComponentLoaders?: Record<string, AsyncComponentLoader>;
+    componentRegistry?: Record<string, unknown>;
+}
+export declare function loadContentComponentEntries(node: ContentBodyNode | null | undefined, tags: Record<string, string>): Array<[string, unknown]>;
+export declare function resolveVueContentComponent(component: string | Renderable | unknown, catalog: ContentComponentCatalog): Promise<string | Renderable | undefined>;
+export declare function resolveDocumentContentComponents(body: ContentBodyNode | null | undefined, options: {
+    tags: Record<string, string>;
+    catalog: ContentComponentCatalog;
+}): Promise<any>;
+export {};

package/dist/integrations/vue/content-components.js

@@ -0,0 +1,67 @@
+import { kebabCase, pascalCase } from "scule";
+import htmlTags from "./html-tags.js";
+export function loadContentComponentEntries(node, tags) {
+  if (!node) {
+    return [];
+  }
+  if (node.type === "text" || node.tag === "binding") {
+    return [];
+  }
+  if (node.type === "root") {
+    return (node.children || []).flatMap((child) => loadContentComponentEntries(child, tags));
+  }
+  const tag = node.tag;
+  if (!tag) {
+    return [];
+  }
+  const mappedTag = typeof node.props?.__ignoreMap === "undefined" ? tags[tag] || tags[pascalCase(tag)] || tags[kebabCase(tag)] || tag : tag;
+  const components = [];
+  if (!htmlTags.includes(mappedTag)) {
+    components.push([tag, mappedTag]);
+  }
+  for (const child of node.children || []) {
+    components.push(...loadContentComponentEntries(child, tags));
+  }
+  return components;
+}
+export async function resolveVueContentComponent(component, catalog) {
+  let resolvedComponent = component;
+  if (typeof component === "string") {
+    if (htmlTags.includes(component)) {
+      return component;
+    }
+    const pascalName = pascalCase(component);
+    const candidates = /* @__PURE__ */ new Set([component, pascalName, kebabCase(component)]);
+    if (catalog.globalComponents?.includes(pascalName)) {
+      for (const candidate of candidates) {
+        const resolved = catalog.componentRegistry?.[candidate];
+        if (resolved && typeof resolved !== "string") {
+          resolvedComponent = resolved;
+          break;
+        }
+      }
+    } else if (catalog.localComponents?.includes(pascalName)) {
+      const loader = catalog.localComponentLoaders?.[pascalName];
+      resolvedComponent = loader ? await loader() : void 0;
+    }
+    if (typeof resolvedComponent === "string") {
+      return resolvedComponent;
+    }
+  }
+  return resolvedComponent;
+}
+export async function resolveDocumentContentComponents(body, options) {
+  if (!body) {
+    return {};
+  }
+  const components = Array.from(new Map(
+    loadContentComponentEntries(body, options.tags).map(([tag, component]) => [`${tag}:${String(component)}`, [tag, component]])
+  ).values());
+  const resolvedEntries = await Promise.all(components.map(async ([tag, component]) => {
+    if (typeof component === "object" && component) {
+      return [tag, component];
+    }
+    return [tag, await resolveVueContentComponent(component, options.catalog)];
+  }));
+  return Object.fromEntries(resolvedEntries);
+}

package/dist/integrations/vue/html-tags

@@ -0,0 +1 @@
+export * from './html-tags.js'

package/dist/integrations/vue/html-tags.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/dist/integrations/vue/html-tags.js

@@ -0,0 +1,119 @@
+export default [
+  "a",
+  "abbr",
+  "address",
+  "area",
+  "article",
+  "aside",
+  "audio",
+  "b",
+  "base",
+  "bdi",
+  "bdo",
+  "blockquote",
+  "body",
+  "br",
+  "button",
+  "canvas",
+  "caption",
+  "cite",
+  "code",
+  "col",
+  "colgroup",
+  "data",
+  "datalist",
+  "dd",
+  "del",
+  "details",
+  "dfn",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "em",
+  "embed",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "i",
+  "iframe",
+  "img",
+  "input",
+  "ins",
+  "kbd",
+  "label",
+  "legend",
+  "li",
+  "link",
+  "main",
+  "map",
+  "mark",
+  "math",
+  "menu",
+  "menuitem",
+  "meta",
+  "meter",
+  "nav",
+  "noscript",
+  "object",
+  "ol",
+  "optgroup",
+  "option",
+  "output",
+  "p",
+  "param",
+  "picture",
+  "pre",
+  "progress",
+  "q",
+  "rb",
+  "rp",
+  "rt",
+  "rtc",
+  "ruby",
+  "s",
+  "samp",
+  "script",
+  "section",
+  "select",
+  "slot",
+  "small",
+  "source",
+  "span",
+  "strong",
+  "style",
+  "sub",
+  "summary",
+  "sup",
+  "svg",
+  "table",
+  "tbody",
+  "td",
+  "template",
+  "textarea",
+  "tfoot",
+  "th",
+  "thead",
+  "time",
+  "title",
+  "tr",
+  "track",
+  "u",
+  "ul",
+  "var",
+  "video",
+  "wbr"
+];

package/dist/integrations/vue/markdown-refs

@@ -0,0 +1 @@
+export * from './markdown-refs.js'

package/dist/integrations/vue/markdown-refs.d.ts

@@ -0,0 +1 @@
+export { rewriteMarkdownRefLinks } from '../../core/references/resolve';

package/dist/integrations/vue/markdown-refs.js

@@ -0,0 +1 @@
+export { rewriteMarkdownRefLinks } from "../../core/references/resolve";