dtwo 2.17.0 → 3.0.0-rc.14

package/dist/head/runtime/components.mjs

@@ -0,0 +1,209 @@
+import { defineComponent } from "kdu";
+import { useHead } from "./composables.mjs";
+const removeUndefinedProps = (props) => Object.fromEntries(Object.entries(props).filter(([, value]) => value !== void 0));
+const setupForUseMeta = (metaFactory, renderChild) => (props, ctx) => {
+  useHead(() => metaFactory({ ...removeUndefinedProps(props), ...ctx.attrs }, ctx));
+  return () => renderChild ? ctx.slots.default?.() : null;
+};
+const globalProps = {
+  accesskey: String,
+  autocapitalize: String,
+  autofocus: {
+    type: Boolean,
+    default: void 0
+  },
+  class: String,
+  contenteditable: {
+    type: Boolean,
+    default: void 0
+  },
+  contextmenu: String,
+  dir: String,
+  draggable: {
+    type: Boolean,
+    default: void 0
+  },
+  enterkeyhint: String,
+  exportparts: String,
+  hidden: {
+    type: Boolean,
+    default: void 0
+  },
+  id: String,
+  inputmode: String,
+  is: String,
+  itemid: String,
+  itemprop: String,
+  itemref: String,
+  itemscope: String,
+  itemtype: String,
+  lang: String,
+  nonce: String,
+  part: String,
+  slot: String,
+  spellcheck: {
+    type: Boolean,
+    default: void 0
+  },
+  style: String,
+  tabindex: String,
+  title: String,
+  translate: String
+};
+export const NoScript = defineComponent({
+  name: "NoScript",
+  inheritAttrs: false,
+  props: {
+    ...globalProps,
+    title: String,
+    body: Boolean,
+    renderPriority: [String, Number]
+  },
+  setup: setupForUseMeta((props, { slots }) => {
+    const noscript = { ...props };
+    const textContent = (slots.default?.() || []).filter(({ children }) => children).map(({ children }) => children).join("");
+    if (textContent) {
+      noscript.children = textContent;
+    }
+    return {
+      noscript: [noscript]
+    };
+  })
+});
+export const Link = defineComponent({
+  name: "Link",
+  inheritAttrs: false,
+  props: {
+    ...globalProps,
+    as: String,
+    crossorigin: String,
+    disabled: Boolean,
+    fetchpriority: String,
+    href: String,
+    hreflang: String,
+    imagesizes: String,
+    imagesrcset: String,
+    integrity: String,
+    media: String,
+    prefetch: {
+      type: Boolean,
+      default: void 0
+    },
+    referrerpolicy: String,
+    rel: String,
+    sizes: String,
+    title: String,
+    type: String,
+    methods: String,
+    target: String,
+    body: Boolean,
+    renderPriority: [String, Number]
+  },
+  setup: setupForUseMeta((link) => ({
+    link: [link]
+  }))
+});
+export const Base = defineComponent({
+  name: "Base",
+  inheritAttrs: false,
+  props: {
+    ...globalProps,
+    href: String,
+    target: String
+  },
+  setup: setupForUseMeta((base) => ({
+    base
+  }))
+});
+export const Title = defineComponent({
+  name: "Title",
+  inheritAttrs: false,
+  setup: setupForUseMeta((_, { slots }) => {
+    const title = slots.default?.()?.[0]?.children || null;
+    if (process.dev && title && typeof title !== "string") {
+      console.error("<Title> can only take a string in its default slot.");
+    }
+    return {
+      title
+    };
+  })
+});
+export const Meta = defineComponent({
+  name: "Meta",
+  inheritAttrs: false,
+  props: {
+    ...globalProps,
+    charset: String,
+    content: String,
+    httpEquiv: String,
+    name: String,
+    body: Boolean,
+    renderPriority: [String, Number]
+  },
+  setup: setupForUseMeta((props) => {
+    const meta = { ...props };
+    if (meta.httpEquiv) {
+      meta["http-equiv"] = meta.httpEquiv;
+      delete meta.httpEquiv;
+    }
+    return {
+      meta: [meta]
+    };
+  })
+});
+export const Style = defineComponent({
+  name: "Style",
+  inheritAttrs: false,
+  props: {
+    ...globalProps,
+    type: String,
+    media: String,
+    nonce: String,
+    title: String,
+    scoped: {
+      type: Boolean,
+      default: void 0
+    },
+    body: Boolean,
+    renderPriority: [String, Number]
+  },
+  setup: setupForUseMeta((props, { slots }) => {
+    const style = { ...props };
+    const textContent = slots.default?.()?.[0]?.children;
+    if (textContent) {
+      if (process.dev && typeof textContent !== "string") {
+        console.error("<Style> can only take a string in its default slot.");
+      }
+      style.children = textContent;
+    }
+    return {
+      style: [style]
+    };
+  })
+});
+export const Head = defineComponent({
+  name: "Head",
+  inheritAttrs: false,
+  setup: (_props, ctx) => () => ctx.slots.default?.()
+});
+export const Html = defineComponent({
+  name: "Html",
+  inheritAttrs: false,
+  props: {
+    ...globalProps,
+    manifest: String,
+    version: String,
+    xmlns: String,
+    renderPriority: [String, Number]
+  },
+  setup: setupForUseMeta((htmlAttrs) => ({ htmlAttrs }), true)
+});
+export const Body = defineComponent({
+  name: "Body",
+  inheritAttrs: false,
+  props: {
+    ...globalProps,
+    renderPriority: [String, Number]
+  },
+  setup: setupForUseMeta((bodyAttrs) => ({ bodyAttrs }), true)
+});

package/dist/head/runtime/composables.d.ts

@@ -0,0 +1,10 @@
+import type { HeadEntryOptions, UseHeadInput, ActiveHeadEntry } from '@kduse/head';
+import type { HeadAugmentations } from '@dtwo/schema';
+/**
+ * You can pass in a meta object, which has keys corresponding to meta tags:
+ * `title`, `base`, `script`, `style`, `meta` and `link`, as well as `htmlAttrs` and `bodyAttrs`.
+ *
+ * Alternatively, for reactive meta state, you can pass in a function
+ * that returns a meta object.
+ */
+export declare function useHead<T extends HeadAugmentations>(input: UseHeadInput<T>, options?: HeadEntryOptions): ActiveHeadEntry<UseHeadInput<T>> | void;

package/dist/head/runtime/composables.mjs

@@ -0,0 +1,4 @@
+import { useDtwoApp } from "#app";
+export function useHead(input, options) {
+  return useDtwoApp()._useHead(input, options);
+}

package/dist/head/runtime/index.d.ts

@@ -0,0 +1,4 @@
+import type { UseHeadInput } from '@kduse/head';
+import type { HeadAugmentations } from '@dtwo/schema';
+export * from './composables';
+export type MetaObject = UseHeadInput<HeadAugmentations>;

package/dist/head/runtime/index.mjs

@@ -0,0 +1 @@
+export * from "./composables.mjs";

package/dist/head/runtime/lib/kdu-meta.plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/head/runtime/lib/kdu-meta.plugin.mjs

@@ -0,0 +1,31 @@
+import { createApp } from "kdu";
+import { createMetaManager } from "kdu-meta";
+import { defineDtwoPlugin } from "#app";
+import { appHead } from "#build/dtwo.config.mjs";
+export default defineDtwoPlugin((dtwoApp) => {
+  const manager = createMetaManager(process.server);
+  manager.addMeta(appHead);
+  dtwoApp.kduApp.use(manager);
+  dtwoApp._useHead = (meta) => manager.addMeta(meta);
+  if (process.client) {
+    const teleportTarget = document.createElement("div");
+    teleportTarget.id = "head-target";
+    document.body.appendChild(teleportTarget);
+    createApp({ render: () => manager.render({}) }).mount("#head-target");
+  }
+  if (process.server) {
+    dtwoApp.ssrContext.renderMeta = async () => {
+      const { renderMetaToString } = await import("kdu-meta/ssr");
+      dtwoApp.ssrContext.teleports = dtwoApp.ssrContext.teleports || {};
+      await renderMetaToString(dtwoApp.app, dtwoApp.ssrContext);
+      return {
+        htmlAttrs: dtwoApp.ssrContext.teleports.htmlAttrs || "",
+        headAttrs: dtwoApp.ssrContext.teleports.headAttrs || "",
+        bodyAttrs: dtwoApp.ssrContext.teleports.bodyAttrs || "",
+        headTags: dtwoApp.ssrContext.teleports.head || "",
+        bodyScriptsPrepend: dtwoApp.ssrContext.teleports["body-prepend"] || "",
+        bodyScripts: dtwoApp.ssrContext.teleports.body || ""
+      };
+    };
+  }
+});

package/dist/head/runtime/lib/kduse-head.plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/head/runtime/lib/kduse-head.plugin.mjs

@@ -0,0 +1,35 @@
+import { createHead, useHead } from "@kduse/head";
+import { defineDtwoPlugin } from "#app";
+import { appHead } from "#build/dtwo.config.mjs";
+export default defineDtwoPlugin((dtwoApp) => {
+  const head = createHead();
+  head.push(appHead);
+  dtwoApp.kduApp.use(head);
+  if (process.client) {
+    let pauseDOMUpdates = true;
+    const unpauseDom = () => {
+      pauseDOMUpdates = false;
+      head.internalHooks.callHook("entries:updated", head.kdhead);
+    };
+    head.internalHooks.hook("dom:beforeRender", (context) => {
+      context.shouldRender = !pauseDOMUpdates;
+    });
+    dtwoApp.hooks.hook("page:start", () => {
+      pauseDOMUpdates = true;
+    });
+    dtwoApp.hooks.hook("page:finish", unpauseDom);
+    dtwoApp.hooks.hook("app:mounted", unpauseDom);
+  }
+  dtwoApp._useHead = useHead;
+  if (process.server) {
+    dtwoApp.ssrContext.renderMeta = async () => {
+      const { renderSSRHead } = await import("@kdhead/ssr");
+      const meta = await renderSSRHead(head.kdhead);
+      return {
+        ...meta,
+        bodyScriptsPrepend: meta.bodyTagsOpen,
+        bodyScripts: meta.bodyTags
+      };
+    };
+  }
+});

package/dist/head/runtime/types.d.ts

@@ -0,0 +1,7 @@
+export type Props = Readonly<Record<string, any>>;
+export type FetchPriority = 'high' | 'low' | 'auto';
+export type CrossOrigin = '' | 'anonymous' | 'use-credentials';
+export type HTTPEquiv = 'content-security-policy' | 'content-type' | 'default-style' | 'refresh' | 'x-ua-compatible';
+export type ReferrerPolicy = '' | 'no-referrer' | 'no-referrer-when-downgrade' | 'same-origin' | 'origin' | 'strict-origin' | 'origin-when-cross-origin' | 'strict-origin-when-cross-origin' | 'unsafe-url';
+export type LinkRelationship = 'alternate' | 'author' | 'canonical' | 'dns-prefetch' | 'help' | 'icon' | 'license' | 'manifest' | 'me' | 'modulepreload' | 'next' | 'pingback' | 'preconnect' | 'prefetch' | 'preload' | 'prerender' | 'prev' | 'search' | 'stylesheet' | (string & {});
+export type Target = '_blank' | '_self' | '_parent' | '_top' | (string & {});

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { DtwoOptions, Dtwo } from '@dtwo/schema';
+import { LoadDtwoOptions } from '@dtwo/kit';
+
+declare function createDtwo(options: DtwoOptions): Dtwo;
+declare function loadDtwo(opts: LoadDtwoOptions): Promise<Dtwo>;
+
+declare function build(dtwo: Dtwo): Promise<void>;
+
+export { build, createDtwo, loadDtwo };