@paroicms/content-loading-plugin 0.26.1 → 0.27.0

package/backend/dist/controller.js

@@ -1,29 +1,50 @@
 import { parseLNodeId } from "@paroicms/public-anywhere-lib";
-export async function makeSearch(service, httpContext, query) {
-    const { q, language, limit, start, tpl } = query;
+export async function makeSearch(service, httpContext, input) {
+    const { q, language, limit, offset, template, sorting } = input;
     const words = q.split(/\s+/).filter((word) => word.length >= 2);
     if (words.length === 0)
         return { total: 0 };
-    await service.renderSearchPartials(httpContext, {
+    const { total, documents } = await service.loadDocuments({
+        load: "list",
+        nodeKind: "document",
+        descriptorName: "search",
         language,
         words,
         limit,
-        start,
-        templateName: tpl,
+        offset,
+        sorting,
+    }, { withTotal: true });
+    const result = [];
+    for (const document of documents) {
+        result.push(await service.renderDocument(template, document));
+    }
+    await service.serve(httpContext, {
+        content: JSON.stringify({
+            total,
+            html: result.length > 0 ? result.join("\n") : undefined,
+        }),
+        contentType: "application/json; charset=utf-8",
     });
 }
-export async function getPartials(service, httpContext, params, labeledBy) {
-    const documentId = params.childrenOf;
-    const parentId = parseLNodeId(documentId);
-    const payload = {
-        templateName: params.template,
-        documentId,
-        offset: params.start,
-        limit: params.limit,
-    };
-    await service.renderChildPartials(httpContext, {
-        params: payload,
-        parentDocumentId: parentId,
-        labeledBy,
+export async function getPartials(service, httpContext, input) {
+    const { childrenOf, labeledWith, offset, limit, sorting, template } = input;
+    const parentDocumentId = parseLNodeId(childrenOf);
+    const documents = await service.loadDocuments({
+        load: "list",
+        nodeKind: "document",
+        descriptorName: "children",
+        parentDocumentId,
+        labeledWith,
+        offset,
+        limit,
+        sorting,
+    });
+    const result = [];
+    for (const document of documents) {
+        result.push(await service.renderDocument(template, document));
+    }
+    await service.serve(httpContext, {
+        content: result.join("\n"),
+        contentType: "text/plain; charset=utf-8",
     });
 }

package/backend/dist/formatters.js

@@ -1,31 +1,41 @@
+import { extractNodeId } from "@paroicms/public-anywhere-lib";
+import { parseSorting } from "@paroicms/public-server-lib";
 import { type } from "arktype";
 export const SearchTextOptionsUrlQueryAT = type({
     language: "string",
     q: "string",
     limit: "string",
-    start: "string",
+    offset: "string",
     tpl: "string",
+    "sorting?": "string|undefined",
     "+": "reject",
-}).pipe((r) => ({
-    language: r.language,
-    q: r.q,
-    limit: Number(r.limit),
-    start: Number(r.start),
-    tpl: r.tpl,
+}).pipe((data) => ({
+    language: data.language,
+    q: data.q,
+    limit: Number(data.limit),
+    offset: Number(data.offset),
+    template: data.tpl,
+    sorting: data.sorting ? parseSorting(data.sorting) : undefined,
 }));
 export const PartialsQueryAT = type({
     template: "string",
     "children-of": "string",
-    start: "string",
+    offset: "string",
     limit: "string",
-    "labeled-t?": "string|undefined",
     "labeled-f?": "string|undefined",
+    "labeled-t?": "string|undefined",
+    "sorting?": "string|undefined",
     "+": "reject",
 }).pipe((data) => ({
     template: data.template,
     childrenOf: data["children-of"],
-    start: Number(data.start),
+    offset: Number(data.offset),
     limit: Number(data.limit),
-    labeledById: data["labeled-t"] ?? undefined,
-    fieldName: data["labeled-f"] ?? undefined,
+    labeledWith: data["labeled-f"] && data["labeled-t"]
+        ? {
+            fieldName: data["labeled-f"],
+            termNodeId: extractNodeId(data["labeled-t"]),
+        }
+        : undefined,
+    sorting: data.sorting ? parseSorting(data.sorting) : undefined,
 }));

package/backend/dist/index.js

@@ -1,26 +1,118 @@
-import { isDef, parseLNodeId } from "@paroicms/public-anywhere-lib";
-import { escapeHtml, makeStylesheetLinkAsyncTag, } from "@paroicms/public-server-lib";
+import { encodeLNodeId, isDef, parseLNodeId } from "@paroicms/public-anywhere-lib";
+import { escapeHtml, extractDocumentsLoadDescriptor, makeStylesheetLinkAsyncTag, } from "@paroicms/public-server-lib";
 import { esmDirName, extractPackageNameAndVersionSync } from "@paroicms/script-lib";
+import { type } from "arktype";
 import { dirname, join } from "node:path";
 import { getPartials, makeSearch } from "./controller.js";
 import { PartialsQueryAT, SearchTextOptionsUrlQueryAT } from "./formatters.js";
 const projectDir = dirname(esmDirName(import.meta.url));
 const packageDir = dirname(projectDir);
 const { version } = extractPackageNameAndVersionSync(packageDir);
+const SearchOpenerAT = type({
+    url: "string",
+    "iconColor?": "string|undefined",
+    "class?": "string|undefined",
+    "+": "reject",
+});
+const SearchAppAT = type({
+    template: "string",
+    by: "number|string",
+    "class?": "string|undefined",
+    "+": "reject",
+}).pipe((v) => ({
+    template: v.template,
+    by: Number(v.by),
+    class: v.class,
+}));
+const InfiniteLoadingAT = type({
+    template: "string",
+    "paginatedDocs?": "object|undefined",
+    "by?": "number|string|undefined",
+    "class?": "string|undefined",
+    "+": "reject",
+}).pipe((v) => ({
+    template: v.template,
+    paginatedDocs: v.paginatedDocs,
+    by: isDef(v.by) ? Number(v.by) : undefined,
+    class: v.class,
+}));
 const plugin = {
     version,
     async siteInit(service) {
         service.setPublicAssetsDirectory(join(packageDir, "frontend", "dist"));
-        service.registerHeadTags(({ html }) => {
-            if (html.includes(`data-effect="paSearchOpener"`) ||
-                html.includes(`data-effect="paSearchApp"`) ||
-                html.includes(`data-effect="paInfiniteLoading"`)) {
+        service.registerHeadTags(({ state }) => {
+            if (state.get("searchOpener") || state.get("searchApp") || state.get("infiniteLoading")) {
                 return [
                     makeStylesheetLinkAsyncTag(`${service.pluginAssetsUrl}/content-loading-plugin.css`),
                     `<script type="module" src="${escapeHtml(`${service.pluginAssetsUrl}/content-loading-plugin.mjs`)}" async></script>`,
                 ];
             }
         });
+        service.registerOutLiquidTagFunction("searchOpener", (service, { namedParameters }) => {
+            service.setRenderState("searchOpener", true);
+            const { iconColor, url, class: className } = SearchOpenerAT.assert(namedParameters);
+            const attributes = [`data-effect="paSearchOpener"`, `data-search-url="${url}"`];
+            if (iconColor) {
+                attributes.push(`data-icon-color="${escapeHtml(iconColor)}"`);
+            }
+            if (className) {
+                attributes.push(`class="${escapeHtml(className)}"`);
+            }
+            return `<span ${attributes.join(" ")}></span>`;
+        });
+        service.registerOutLiquidTagFunction("searchApp", (service, { namedParameters }) => {
+            service.setRenderState("searchApp", true);
+            const { template, by, class: className } = SearchAppAT.assert(namedParameters);
+            if (!template.endsWith(".public") && !template.endsWith(".public.liquid")) {
+                throw new Error(`Invalid template name: "${template}" (should ends with .public)`);
+            }
+            const attributes = [
+                `data-effect="paSearchApp"`,
+                `data-template="${escapeHtml(template)}"`,
+                `data-limit="${by}"`,
+            ];
+            if (className) {
+                attributes.push(`class="${escapeHtml(className)}"`);
+            }
+            return `<div ${attributes.join(" ")}></div>`;
+        });
+        service.registerOutLiquidTagFunction("infiniteLoading", async (service, { namedParameters }) => {
+            service.setRenderState("infiniteLoading", true);
+            const { template, paginatedDocs, by, class: className, } = InfiniteLoadingAT.assert(namedParameters);
+            if (!template.endsWith(".public") && !template.endsWith(".public.liquid")) {
+                throw new Error(`Invalid template name: "${template}" (should ends with .public)`);
+            }
+            if (!paginatedDocs)
+                return "";
+            const loadDescriptor = extractDocumentsLoadDescriptor(paginatedDocs);
+            if (!loadDescriptor || loadDescriptor.descriptorName !== "children") {
+                throw new Error("[infiniteLoading] Invalid paginatedDocs parameter");
+            }
+            const attributes = [
+                `data-effect="paInfiniteLoading"`,
+                `data-template="${escapeHtml(template)}"`,
+                `data-limit="${by ?? paginatedDocs.pageSize}"`,
+                `data-offset="${paginatedDocs.pageSize}"`,
+                `data-total="${paginatedDocs.total}"`,
+                `data-parent-document-id="${encodeLNodeId(loadDescriptor.parentDocumentId)}"`,
+            ];
+            if (isDef(loadDescriptor.sorting)) {
+                attributes.push(`data-sorting="${escapeHtml(encodeSorting(loadDescriptor.sorting))}"`);
+            }
+            if (isDef(loadDescriptor.labeledWith)) {
+                attributes.push(`data-labeled-with="${escapeHtml(loadDescriptor.labeledWith.fieldName)}"`);
+                attributes.push(`data-term-node-id="${escapeHtml(loadDescriptor.labeledWith.termNodeId)}"`);
+            }
+            if (className) {
+                attributes.push(`class="${escapeHtml(className)}"`);
+            }
+            const rendered = [];
+            for (const item of paginatedDocs.items) {
+                const html = await service.renderDocument(template, item);
+                rendered.push(html);
+            }
+            return `<div ${attributes.join(" ")}>${rendered.join("\n")}</div>`;
+        });
         service.setPublicApiHandler(async (service, httpContext, relativePath) => {
             const { req, res } = httpContext;
             if (req.method === "GET" && relativePath === "/search") {
@@ -35,19 +127,12 @@ const plugin = {
             }
             if (req.method === "GET" && relativePath === "/partials") {
                 const input = PartialsQueryAT.assert(req.query);
-                const { labeledById, fieldName } = input;
-                const termNodeId = isDef(labeledById) ? toNodeId(labeledById) : undefined;
                 const { language } = parseLNodeId(input.childrenOf);
                 const renderService = await service.openRenderingService({
                     language,
                     urlLike: relativePath,
                 });
-                await getPartials(renderService, httpContext, input, termNodeId !== undefined && fieldName
-                    ? {
-                        fieldName,
-                        termNodeId,
-                    }
-                    : undefined);
+                await getPartials(renderService, httpContext, input);
                 await renderService.close();
                 return;
             }
@@ -57,7 +142,9 @@ const plugin = {
         });
     },
 };
-function toNodeId(nodeOrLNodeId) {
-    return nodeOrLNodeId.indexOf(":") !== -1 ? parseLNodeId(nodeOrLNodeId).nodeId : nodeOrLNodeId;
-}
 export default plugin;
+function encodeSorting(sorting) {
+    if (sorting === "manual")
+        return "manual";
+    return sorting.map(({ fieldName, direction }) => `${fieldName} ${direction}`).join(",");
+}