@jsxpdf/jsxpdf 0.0.1-alpha.0

package/dist/index.js

@@ -0,0 +1,700 @@
+// src/index.ts
+import {
+  Canvas,
+  Circle,
+  Checkbox,
+  ClipPath,
+  Defs,
+  Document as Document2,
+  Ellipse,
+  Table,
+  TableBody,
+  TableCell,
+  TableFooter,
+  TableHead,
+  TableRow,
+  FieldSet,
+  G,
+  Image,
+  Line,
+  LinearGradient,
+  Link,
+  List,
+  Note,
+  Page as Page2,
+  PageBreak,
+  Path,
+  Polygon,
+  Polyline,
+  RadialGradient,
+  Rect,
+  Select,
+  Stop,
+  Svg,
+  Text,
+  TextInput,
+  Tspan,
+  View as View2
+} from "@jsxpdf/core";
+import { Font, StyleSheet } from "@jsxpdf/core";
+
+// src/render.ts
+import { concatUint8Arrays } from "@jsxpdf/core";
+import {
+  createPdfRuntime
+} from "@jsxpdf/render";
+import { renderPdf } from "@jsxpdf/render-pdfkit";
+var runtime = createPdfRuntime(renderPdf);
+var chunkToUint8Array = (chunk2) => {
+  if (chunk2 instanceof Uint8Array) return chunk2;
+  if (typeof chunk2 === "string") return new TextEncoder().encode(chunk2);
+  return new Uint8Array(chunk2);
+};
+var collectStreamBytes = (stream) => new Promise((resolve, reject) => {
+  const chunks = [];
+  let ended = false;
+  let finished = false;
+  let settled = false;
+  let resolveTimer = null;
+  const settle = () => {
+    if (settled) return;
+    settled = true;
+    if (resolveTimer) clearTimeout(resolveTimer);
+    resolve(concatUint8Arrays(chunks));
+  };
+  const maybeResolve = () => {
+    if (settled) return;
+    if (ended && finished) return settle();
+    if (ended || finished) {
+      if (resolveTimer) clearTimeout(resolveTimer);
+      resolveTimer = setTimeout(settle, 0);
+    }
+  };
+  stream.on("data", (chunk2) => {
+    chunks.push(chunkToUint8Array(chunk2));
+  });
+  stream.on("end", () => {
+    ended = true;
+    maybeResolve();
+  });
+  stream.on("finish", () => {
+    finished = true;
+    maybeResolve();
+  });
+  stream.on("error", reject);
+});
+var wrapInstance = (instance) => ({
+  ...instance,
+  async toUint8Array() {
+    return collectStreamBytes(await instance.toStream());
+  },
+  async toBlob() {
+    const bytes = await this.toUint8Array();
+    return new Blob([Uint8Array.from(bytes)], { type: "application/pdf" });
+  }
+});
+var pdf = (initialValue, options = {}) => {
+  return wrapInstance(runtime.pdf(initialValue, options));
+};
+var renderToUint8Array = (element, options = {}) => pdf(element, options).toUint8Array();
+var renderToBlob = (element, options = {}) => pdf(element, options).toBlob();
+var compile = async (component, options = {}) => {
+  const template = await runtime.compile(component, options);
+  const toUint8Array = async (props, renderOptions = {}) => {
+    return collectStreamBytes(await template.toStream(props, renderOptions));
+  };
+  return {
+    ...template,
+    toUint8Array,
+    async toBlob(props, renderOptions = {}) {
+      const bytes = await toUint8Array(props, renderOptions);
+      return new Blob([Uint8Array.from(bytes)], { type: "application/pdf" });
+    }
+  };
+};
+
+// src/repeat.ts
+import { Document, Page, View, createBindingToken, isBindingToken, materializeChildren, materializeElement, parseSizeValue } from "@jsxpdf/core";
+import {
+  buildConcatenatedDocumentLayout,
+  compilePrecompiledTemplateSync,
+  initCompiledRenderState,
+  runSinglePageIncrementalPipeline
+} from "@jsxpdf/layout";
+
+// src/jsx-runtime.ts
+import { Fragment, jsx, jsxs, jsxDEV } from "@jsxpdf/core/jsx-runtime";
+
+// src/repeat.ts
+var pageSizes = {
+  A0: [2383.94, 3370.39],
+  A1: [1683.78, 2383.94],
+  A2: [1190.55, 1683.78],
+  A3: [841.89, 1190.55],
+  A4: [595.28, 841.89],
+  A5: [419.53, 595.28],
+  A6: [297.64, 419.53],
+  LETTER: [612, 792],
+  LEGAL: [612, 1008],
+  TABLOID: [792, 1224]
+};
+var TRACKED_PATH_SYMBOL = /* @__PURE__ */ Symbol.for("jsxpdf.trackedPath");
+var h = (type, props, ...children) => {
+  const normalizedChildren = children.flat(Infinity).filter((child) => child !== void 0 && child !== null && child !== false);
+  const nextProps = { ...props ?? {} };
+  if (normalizedChildren.length === 1) {
+    nextProps.children = normalizedChildren[0];
+  } else if (normalizedChildren.length > 1) {
+    nextProps.children = normalizedChildren;
+  }
+  const key = nextProps.key;
+  delete nextProps.key;
+  return Array.isArray(nextProps.children) ? jsxs(type, nextProps, key) : jsx(type, nextProps, key);
+};
+var chunk = (items, size) => {
+  const result = [];
+  for (let index = 0; index < items.length; index += size) {
+    result.push(items.slice(index, index + size));
+  }
+  return result;
+};
+var resolveRepeatPageSize = (size, orientation, dpi = 72) => {
+  let resolved;
+  if (typeof size === "string") {
+    resolved = pageSizes[size.toUpperCase()] ?? pageSizes.A4;
+  } else if (Array.isArray(size)) {
+    resolved = [
+      parseSizeValue(size[0], 0, dpi) ?? pageSizes.A4[0],
+      parseSizeValue(size[1], 0, dpi) ?? pageSizes.A4[1]
+    ];
+  } else if (typeof size === "number") {
+    resolved = [size, size];
+  } else if (size && typeof size === "object") {
+    resolved = [
+      parseSizeValue(size.width, 0, dpi) ?? pageSizes.A4[0],
+      parseSizeValue(size.height, 0, dpi) ?? pageSizes.A4[1]
+    ];
+  } else {
+    resolved = pageSizes.A4;
+  }
+  return orientation === "landscape" ? [resolved[1], resolved[0]] : resolved;
+};
+var reorderForColumnFill = (items, columns, rows) => {
+  const perPage = Math.max(1, columns * rows);
+  const reordered = [];
+  for (const pageItems of chunk(items, perPage)) {
+    for (let row = 0; row < rows; row += 1) {
+      for (let column = 0; column < columns; column += 1) {
+        const sourceIndex = column * rows + row;
+        const item = pageItems[sourceIndex];
+        if (item !== void 0) reordered.push(item);
+      }
+    }
+  }
+  return reordered;
+};
+var isElement = (value) => typeof value === "object" && value !== null && "type" in value && "props" in value;
+var resolveTrackedPathValue = (root, path) => {
+  let current = root;
+  for (const segment of path) {
+    if (current == null) return void 0;
+    current = current[segment];
+  }
+  return current;
+};
+var resolveBindingValues = (value, rootProps) => {
+  if (isBindingToken(value)) {
+    return resolveTrackedPathValue(rootProps, value.path);
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => resolveBindingValues(entry, rootProps));
+  }
+  if (value instanceof Date || value instanceof Uint8Array) return value;
+  if (typeof value === "function") return value;
+  if (value && typeof value === "object") {
+    const source = value;
+    const resolved = {};
+    for (const [key, entry] of Object.entries(source)) {
+      resolved[key] = resolveBindingValues(entry, rootProps);
+    }
+    return resolved;
+  }
+  return value;
+};
+var extractConcatDocuments = (value) => {
+  const resolved = materializeElement(value);
+  const children = materializeChildren(resolved);
+  const documents = [];
+  for (const child of children) {
+    const resolvedChild = materializeElement(child);
+    if (!isElement(resolvedChild)) continue;
+    if (resolvedChild.type === Document) {
+      documents.push(resolvedChild);
+      continue;
+    }
+    if (resolvedChild.type === Page) {
+      documents.push(h(Document, null, resolvedChild));
+      continue;
+    }
+    throw new Error(`Concat only accepts Document, RepeatedDocument, or Page children. Received ${String(resolvedChild.type)}.`);
+  }
+  return documents;
+};
+function CardSlot(props) {
+  const { __repeatSlotMetrics, padding = 0, overflow = "clip", clip, wrap, style, children, ...rest } = props;
+  if (!__repeatSlotMetrics) {
+    throw new Error("CardSlot must be used inside Repeat.");
+  }
+  const contentWidth = Math.max(0, __repeatSlotMetrics.width - padding * 2);
+  const contentHeight = Math.max(0, __repeatSlotMetrics.height - padding * 2);
+  return h(
+    View,
+    {
+      ...rest,
+      wrap: wrap ?? false,
+      clip: clip ?? overflow !== "error",
+      repeatSlotConfig: {
+        overflow,
+        contentWidth,
+        contentHeight
+      },
+      style: [
+        style,
+        {
+          left: __repeatSlotMetrics.x,
+          top: __repeatSlotMetrics.y,
+          width: __repeatSlotMetrics.width,
+          height: __repeatSlotMetrics.height,
+          paddingTop: padding,
+          paddingRight: padding,
+          paddingBottom: padding,
+          paddingLeft: padding,
+          position: "absolute"
+        }
+      ]
+    },
+    h(
+      View,
+      {
+        repeatSlotContent: true,
+        wrap: false,
+        style: {
+          width: contentWidth,
+          height: contentHeight,
+          position: "relative"
+        }
+      },
+      children
+    )
+  );
+}
+var getRepeatedDocumentPlan = (props) => {
+  if (isBindingToken(props.items)) {
+    throw new Error("jsxpdf.compile.unsupported: RepeatedDocument requires static items during layout.");
+  }
+  const items = props.fill === "column" ? reorderForColumnFill(props.items, props.slots.columns, props.slots.rows) : [...props.items];
+  const columns = Math.max(1, Math.floor(props.slots.columns));
+  const rows = Math.max(1, Math.floor(props.slots.rows));
+  const gap = Math.max(0, props.gap ?? 0);
+  const perPage = columns * rows;
+  const [pageWidth, pageHeight] = resolveRepeatPageSize(
+    props.page?.size,
+    props.page?.orientation,
+    props.page?.dpi
+  );
+  const totalHorizontalGap = gap * (columns - 1);
+  const totalVerticalGap = gap * (rows - 1);
+  const slotWidth = (pageWidth - totalHorizontalGap) / columns;
+  const slotHeight = (pageHeight - totalVerticalGap) / rows;
+  const pageCount = Math.ceil(items.length / perPage);
+  return {
+    items,
+    columns,
+    gap,
+    perPage,
+    pageWidth,
+    pageHeight,
+    pageCount,
+    slotWidth,
+    slotHeight
+  };
+};
+var createRepeatedPageDocument = (props, pageIndex) => {
+  const plan = getRepeatedDocumentPlan(props);
+  const pageItems = plan.items.slice(pageIndex * plan.perPage, pageIndex * plan.perPage + plan.perPage);
+  const trackedItemPaths = pageItems.map((item) => item && typeof item === "object" && Array.isArray(item[TRACKED_PATH_SYMBOL]) ? [...item[TRACKED_PATH_SYMBOL]] : null).filter((path) => Array.isArray(path) && path.length >= 2 && typeof path[path.length - 1] === "number");
+  const firstTrackedPath = trackedItemPaths[0];
+  const pageCollectionPath = firstTrackedPath && trackedItemPaths.every(
+    (path) => path.length === firstTrackedPath.length && path.slice(0, -1).every((segment, index) => segment === firstTrackedPath[index])
+  ) ? firstTrackedPath.slice(0, -1) : void 0;
+  const pageIndexRange = pageCollectionPath && trackedItemPaths.length > 0 ? [
+    Math.min(...trackedItemPaths.map((path) => path[path.length - 1])),
+    Math.max(...trackedItemPaths.map((path) => path[path.length - 1]))
+  ] : void 0;
+  return h(
+    Document,
+    {
+      key: `repeated-document-${pageIndex + 1}`
+    },
+    h(
+      Page,
+      {
+        key: `repeat-page-${pageIndex + 1}`,
+        size: [plan.pageWidth, plan.pageHeight],
+        dpi: props.page?.dpi,
+        __repeatTrackedCollectionPath: pageCollectionPath,
+        __repeatTrackedIndexRange: pageIndexRange,
+        style: [
+          {
+            padding: 0,
+            position: "relative"
+          },
+          props.page?.style
+        ]
+      },
+      ...pageItems.map((item, itemIndex) => {
+        const childIndex = pageIndex * plan.perPage + itemIndex;
+        const row = Math.floor(itemIndex / plan.columns);
+        const column = itemIndex % plan.columns;
+        const rendered = typeof props.children === "function" ? props.children(item, childIndex) : props.children;
+        const metrics = {
+          x: column * (plan.slotWidth + plan.gap),
+          y: row * (plan.slotHeight + plan.gap),
+          width: plan.slotWidth,
+          height: plan.slotHeight
+        };
+        const repeatTrackedItemPath = item && typeof item === "object" && Array.isArray(item[TRACKED_PATH_SYMBOL]) ? [...item[TRACKED_PATH_SYMBOL]] : void 0;
+        if (isElement(rendered) && rendered.type === CardSlot) {
+          return {
+            ...rendered,
+            props: {
+              ...rendered.props,
+              __repeatSlotMetrics: metrics,
+              __repeatTrackedItemPath: repeatTrackedItemPath
+            }
+          };
+        }
+        return h(CardSlot, {
+          key: `repeat-slot-${childIndex + 1}`,
+          __repeatSlotMetrics: metrics,
+          __repeatTrackedItemPath: repeatTrackedItemPath,
+          children: rendered
+        });
+      })
+    )
+  );
+};
+var createRepeatedPages = (props) => {
+  const plan = getRepeatedDocumentPlan(props);
+  return Array.from({ length: plan.pageCount }, (_, pageIndex) => {
+    const document = createRepeatedPageDocument(props, pageIndex);
+    return materializeChildren(document.props.children ?? [])[0];
+  });
+};
+var createRepeatedSlotElement = (props, item, itemIndex, metrics) => {
+  const rendered = typeof props.children === "function" ? props.children(item, itemIndex) : props.children;
+  const repeatTrackedItemPath = item && typeof item === "object" && Array.isArray(item[TRACKED_PATH_SYMBOL]) ? [...item[TRACKED_PATH_SYMBOL]] : void 0;
+  if (isElement(rendered) && rendered.type === CardSlot) {
+    return {
+      ...rendered,
+      props: {
+        ...rendered.props,
+        __repeatSlotMetrics: metrics,
+        __repeatTrackedItemPath: repeatTrackedItemPath
+      }
+    };
+  }
+  return h(CardSlot, {
+    key: `repeat-slot-${itemIndex + 1}`,
+    __repeatSlotMetrics: metrics,
+    __repeatTrackedItemPath: repeatTrackedItemPath,
+    children: rendered
+  });
+};
+var canCompileRepeatedSchema = (props) => {
+  if (!isBindingToken(props.items)) return false;
+  if (isBindingToken(props.page?.size) || isBindingToken(props.page?.orientation) || isBindingToken(props.page?.dpi)) return false;
+  if (isBindingToken(props.gap) || isBindingToken(props.fill)) return false;
+  if (isBindingToken(props.slots.columns) || isBindingToken(props.slots.rows)) return false;
+  return true;
+};
+var createRepeatedSchemaRender = (props) => {
+  if (!isBindingToken(props.items)) {
+    throw new Error("jsxpdf.compile.unsupported: RepeatedDocument schema render requires binding-token items.");
+  }
+  const itemsPath = [...props.items.path];
+  const staticPlan = getRepeatedDocumentPlan({
+    ...props,
+    items: []
+  });
+  const documentTemplate = compilePrecompiledTemplateSync(h(Document, {
+    title: props.title,
+    author: props.author,
+    subject: props.subject,
+    creator: props.creator,
+    keywords: props.keywords,
+    producer: props.producer,
+    language: props.language,
+    creationDate: props.creationDate,
+    modificationDate: props.modificationDate,
+    pdfVersion: props.pdfVersion,
+    tagged: props.tagged,
+    attachments: props.attachments,
+    xmp: props.xmp,
+    pdfaid: props.pdfaid,
+    pageMode: props.pageMode,
+    pageLayout: props.pageLayout
+  }));
+  const pageTemplate = compilePrecompiledTemplateSync(
+    h(
+      Document,
+      null,
+      h(
+        Page,
+        {
+          size: [staticPlan.pageWidth, staticPlan.pageHeight],
+          dpi: props.page?.dpi,
+          style: [
+            {
+              padding: 0,
+              position: "relative"
+            },
+            props.page?.style
+          ]
+        }
+      )
+    )
+  );
+  const slotTemplate = compilePrecompiledTemplateSync(
+    createRepeatedSlotElement(
+      props,
+      createBindingToken(["__repeatItem"], "", void 0, true),
+      0,
+      {
+        x: 0,
+        y: 0,
+        width: staticPlan.slotWidth,
+        height: staticPlan.slotHeight
+      }
+    )
+  );
+  const declaredBindingPaths = [
+    itemsPath,
+    ...documentTemplate.placeholders.flatMap((entry) => [
+      ...entry.bindingPath ? [entry.bindingPath] : [],
+      ...entry.bindingPaths ?? []
+    ]),
+    ...pageTemplate.placeholders.flatMap((entry) => [
+      ...entry.bindingPath ? [entry.bindingPath] : [],
+      ...entry.bindingPaths ?? []
+    ]),
+    ...slotTemplate.placeholders.flatMap((entry) => [
+      ...entry.bindingPath ? [entry.bindingPath] : [],
+      ...entry.bindingPaths ?? []
+    ])
+  ].flatMap((path) => path[0] === "__repeatItem" ? [path] : Array.from({ length: path.length }, (_, index) => path.slice(0, index + 1)));
+  const uniqueBindingPaths = declaredBindingPaths.filter(
+    (path, index, all) => all.findIndex(
+      (candidate) => candidate.length === path.length && candidate.every((segment, segmentIndex) => segment === path[segmentIndex])
+    ) === index
+  );
+  const indexedSlotElements = Array.from({ length: staticPlan.perPage }, (_, i) => {
+    const row = Math.floor(i / staticPlan.columns);
+    const col = i % staticPlan.columns;
+    return createRepeatedSlotElement(
+      props,
+      createBindingToken(["__slots", i], "", void 0, true),
+      i,
+      {
+        x: col * (staticPlan.slotWidth + staticPlan.gap),
+        y: row * (staticPlan.slotHeight + staticPlan.gap),
+        width: staticPlan.slotWidth,
+        height: staticPlan.slotHeight
+      }
+    );
+  });
+  const perPageCompiledTemplate = compilePrecompiledTemplateSync(
+    h(
+      Document,
+      null,
+      h(Page, {
+        size: [staticPlan.pageWidth, staticPlan.pageHeight],
+        dpi: props.page?.dpi,
+        style: [{ padding: 0, position: "relative" }, props.page?.style]
+      }, ...indexedSlotElements)
+    )
+  );
+  let pageOptimizedStatePromise = null;
+  let renderQueue = Promise.resolve();
+  const getPageOptimizedState = () => {
+    if (!pageOptimizedStatePromise) {
+      pageOptimizedStatePromise = initCompiledRenderState(perPageCompiledTemplate).then(
+        ({ renderState, incrementalLayoutState }) => ({ renderState, incrementalState: incrementalLayoutState })
+      );
+    }
+    return pageOptimizedStatePromise;
+  };
+  return Object.assign(
+    (rootProps) => {
+      const resolvedItems = resolveTrackedPathValue(rootProps, itemsPath);
+      if (!Array.isArray(resolvedItems)) {
+        throw new Error("jsxpdf.compile.unsupported: RepeatedDocument items must resolve to an array at render time.");
+      }
+      const allItems = props.fill === "column" ? reorderForColumnFill(resolvedItems, staticPlan.columns, staticPlan.perPage / staticPlan.columns) : resolvedItems;
+      const pageCount = Math.ceil(allItems.length / staticPlan.perPage);
+      if (allItems.length > 0 && allItems.length % staticPlan.perPage === 0) {
+        const result = renderQueue.then(async () => {
+          const state = await getPageOptimizedState();
+          const pageLayouts = [];
+          for (let pageIndex = 0; pageIndex < pageCount; pageIndex++) {
+            const pageItems = allItems.slice(pageIndex * staticPlan.perPage, (pageIndex + 1) * staticPlan.perPage);
+            const { pageLayout, incrementalState: nextState } = await runSinglePageIncrementalPipeline(
+              state.renderState,
+              state.incrementalState,
+              { __slots: pageItems }
+            );
+            state.incrementalState = nextState;
+            pageLayouts.push(pageLayout);
+          }
+          const documentProps = resolveBindingValues({
+            title: props.title,
+            author: props.author,
+            subject: props.subject,
+            creator: props.creator,
+            keywords: props.keywords,
+            producer: props.producer,
+            language: props.language,
+            creationDate: props.creationDate,
+            modificationDate: props.modificationDate,
+            pdfVersion: props.pdfVersion,
+            tagged: props.tagged,
+            attachments: props.attachments,
+            xmp: props.xmp,
+            pdfaid: props.pdfaid,
+            pageMode: props.pageMode,
+            pageLayout: props.pageLayout
+          }, rootProps);
+          return buildConcatenatedDocumentLayout(documentProps, pageLayouts);
+        });
+        renderQueue = result.then(() => {
+        }).catch(() => {
+        });
+        return result;
+      }
+      const concreteProps = {
+        ...resolveBindingValues(props, rootProps),
+        items: resolvedItems
+      };
+      return materializeElement(createRepeatedDocumentElement(concreteProps));
+    },
+    { bindingPaths: uniqueBindingPaths }
+  );
+};
+var createRepeatedDocumentElement = (props) => {
+  const concatDocuments = createRepeatedPages(props).map((page) => h(Document, null, page));
+  return h(
+    Document,
+    {
+      title: props.title,
+      author: props.author,
+      subject: props.subject,
+      creator: props.creator,
+      keywords: props.keywords,
+      producer: props.producer,
+      language: props.language,
+      creationDate: props.creationDate,
+      modificationDate: props.modificationDate,
+      pdfVersion: props.pdfVersion,
+      tagged: props.tagged,
+      attachments: props.attachments,
+      xmp: props.xmp,
+      pdfaid: props.pdfaid,
+      pageMode: props.pageMode,
+      pageLayout: props.pageLayout,
+      concatDocuments
+    }
+  );
+};
+function RepeatedDocument(props) {
+  if (canCompileRepeatedSchema(props)) {
+    const schemaRender = createRepeatedSchemaRender(props);
+    return h(
+      Document,
+      {
+        title: typeof props.title === "string" ? props.title : void 0,
+        __compiledBindingPaths: schemaRender.bindingPaths,
+        __compiledSchemaRender: schemaRender
+      }
+    );
+  }
+  if (isBindingToken(props.items)) {
+    throw new Error("jsxpdf.compile.unsupported: RepeatedDocument requires static layout props during compile.");
+  }
+  return createRepeatedDocumentElement(props);
+}
+function Repeat(props) {
+  return h(Fragment, null, ...createRepeatedPages(props));
+}
+function Concat(props) {
+  const { children, ...documentProps } = props;
+  return h(
+    Document,
+    {
+      ...documentProps,
+      concatDocuments: extractConcatDocuments(children ?? [])
+    }
+  );
+}
+
+// src/index.ts
+import { configureYogaRuntime, getYogaBackend } from "@jsxpdf/layout";
+export {
+  Canvas,
+  CardSlot,
+  Checkbox,
+  Circle,
+  ClipPath,
+  Concat,
+  Defs,
+  Document2 as Document,
+  Ellipse,
+  FieldSet,
+  Font,
+  G,
+  Image,
+  Line,
+  LinearGradient,
+  Link,
+  List,
+  Note,
+  Page2 as Page,
+  PageBreak,
+  Path,
+  Polygon,
+  Polyline,
+  RadialGradient,
+  Rect,
+  Repeat,
+  RepeatedDocument,
+  Select,
+  Stop,
+  StyleSheet,
+  Svg,
+  Table,
+  TableBody,
+  TableCell,
+  TableFooter,
+  TableHead,
+  TableRow,
+  Text,
+  TextInput,
+  Tspan,
+  View2 as View,
+  compile,
+  configureYogaRuntime,
+  getYogaBackend,
+  pdf,
+  renderToBlob,
+  renderToUint8Array
+};
+//# sourceMappingURL=index.js.map