@alanizcreative/formation-static 1.3.0-beta.29

package/lib/render/renderTypes.d.ts

@@ -0,0 +1,198 @@
+import type { Generic, GenericStrings, InternalLink, Taxonomy, ParentArgs } from '../global/globalTypes.js';
+import type { NavigationList, NavigationItem, NavigationProps } from '../components/Navigation/NavigationTypes.js';
+import type { Navigation } from '../components/Navigation/Navigation.js';
+import type { RichTextHeading } from '../text/RichText/RichTextTypes.js';
+import type { StoreParent } from '../store/storeTypes.js';
+import { PaginationData } from '../components/Pagination/PaginationTypes.js';
+export interface RenderMeta {
+    title?: string;
+    paginationTitle?: string;
+    description?: string;
+    url?: string;
+    image?: string;
+    canonical?: string;
+    canonicalParams?: string;
+    prev?: string;
+    next?: string;
+    noIndex?: boolean;
+    isIndex?: boolean;
+}
+export interface RenderBase {
+    pageData: RenderItem;
+    pageHeadings: RichTextHeading[][];
+    pageContains: string[];
+    serverlessData?: RenderServerlessData;
+    previewData?: RenderPreviewData;
+}
+export interface RenderServerlessData {
+    path: string;
+    query?: Generic;
+}
+export interface RenderPreviewData {
+    id: string;
+    contentType: string;
+}
+export interface RenderRedirect {
+    redirect: string[];
+}
+export interface RenderTag {
+    id: string;
+    name: string;
+}
+export interface RenderMetaTags {
+    tags?: RenderTag[];
+}
+export interface RenderFile {
+    path?: string;
+    url?: string;
+    name?: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+    size?: number;
+    format?: string;
+    type?: string;
+    sizes?: Record<number, string>;
+}
+export interface RenderRichText {
+    tag?: string;
+    link?: string;
+    internalLink?: InternalLink;
+    content?: RenderItem[] | string;
+    attr?: string | GenericStrings;
+}
+export interface RenderTemplate {
+    content: RenderItem[];
+    namedContent: Record<string, RenderItem>;
+    templates: RenderItem[];
+}
+export interface RenderNavigationsArgs extends NavigationProps {
+    title?: string;
+    parents: StoreParent[];
+}
+export type RenderNavigations = (args: RenderNavigationsArgs) => Navigation | undefined | Promise<Navigation | undefined>;
+export interface RenderHttpErrorArgs extends Generic {
+    code: number;
+}
+export type RenderHttpError = (args: RenderHttpErrorArgs) => string | Promise<string>;
+export interface RenderFunctionArgs<T = any, R = RenderItem, P = ParentArgs> {
+    args: 0 extends (1 & T) ? any : T;
+    parents?: P[];
+    pageData?: R;
+    pageContains?: string[];
+    navigations?: Navigation;
+    serverlessData?: RenderServerlessData;
+    previewData?: RenderPreviewData;
+    headings?: RichTextHeading[];
+    children?: R[];
+}
+export type RenderFunction<T = any, R = RenderItem, P = ParentArgs> = (props: RenderFunctionArgs<T, R, P>) => string | string[] | Promise<string | string[]>;
+export type RenderFunctions<T = any, R = RenderItem, P = ParentArgs> = Record<string, RenderFunction<T, R, P>>;
+export interface RenderFunctionsArgs {
+    functions: RenderFunctions;
+    layout: RenderLayout;
+    navigations?: RenderNavigations;
+    httpError?: RenderHttpError;
+}
+export interface RenderContentArgs extends RenderBase {
+    content: RenderItem[];
+    parents: ParentArgs[];
+    navigations?: Navigation;
+    headingsIndex?: number;
+    depth?: number;
+}
+export interface RenderItem extends Generic, Partial<Taxonomy> {
+    id?: string;
+    contentType?: string;
+    renderType?: string;
+    tag?: string;
+    link?: string;
+    internalLink?: InternalLink;
+    slug?: string;
+    title?: string;
+    content?: RenderItem[] | string;
+    meta?: RenderMeta;
+    baseUrl?: string;
+    archive?: string;
+    parent?: RenderItem;
+    taxonomy?: Taxonomy;
+    metadata?: RenderMetaTags;
+    pagination?: PaginationData;
+}
+export interface RenderItemArgs {
+    item: RenderItem;
+    serverlessData?: RenderServerlessData;
+    previewData?: RenderPreviewData;
+}
+export interface RenderItemReturn {
+    serverlessRender?: boolean;
+    pageData?: RenderItem;
+    data?: {
+        slug: string;
+        output: string;
+    };
+}
+export interface RenderInlineItem extends Omit<RenderItem, 'id' | 'slug' | 'contentType' | 'content'> {
+    id: string;
+    slug: string;
+    contentType: string;
+    content: RenderItem[] | string;
+}
+export interface RenderItemStartActionArgs extends RenderBase {
+    id: string;
+    contentType: string;
+}
+export interface RenderItemActionArgs extends RenderBase {
+    id: string;
+    contentType: string;
+    slug: string;
+    output: string;
+}
+export interface RenderLayoutArgs {
+    id: string;
+    meta: RenderMeta;
+    navigations?: Navigation;
+    contentType: string;
+    content: string;
+    slug: string;
+    pageData: RenderItem;
+    pageHeadings?: RichTextHeading[][];
+    pageContains?: string[];
+    serverlessData?: RenderServerlessData;
+    previewData?: RenderPreviewData;
+}
+export type RenderLayout = (args: RenderLayoutArgs) => string | Promise<string>;
+export interface RenderAllData extends Generic {
+    navigation?: NavigationList[];
+    navigationItem?: NavigationItem[];
+    redirect?: RenderRedirect[];
+    content: {
+        page: RenderItem[];
+        [key: string]: RenderItem[];
+    };
+}
+export interface RenderArgs {
+    allData?: RenderAllData;
+    serverlessData?: RenderServerlessData;
+    previewData?: RenderPreviewData;
+}
+export interface RenderReturn {
+    slug: string;
+    output: string;
+}
+export type RenderContentFilter = <T>(content: string[], args: ParentArgs<T>) => Promise<string[]> | string[];
+export type RenderItemFilter = (output: string, args: RenderItemActionArgs) => Promise<string> | string;
+export type RenderItemDataFilter = (item: RenderItem, args: {
+    contentType: string;
+}) => Promise<RenderItem> | RenderItem;
+export type RenderStartAction = (args: RenderArgs) => Promise<void> | void;
+export interface RenderEndActionArgs extends RenderArgs {
+    data: RenderReturn[] | RenderReturn;
+}
+export type RenderEndAction = (args: RenderEndActionArgs) => Promise<void> | void;
+export type RenderItemStartAction = (args: RenderItemStartActionArgs) => Promise<void> | void;
+export type RenderItemEndAction = (args: RenderItemActionArgs) => Promise<void> | void;
+export interface RenderDataMeta {
+    total?: number;
+    totalPages?: number;
+}

package/lib/render/renderTypes.js

@@ -0,0 +1 @@
+export{};

package/lib/serverless/Ajax/Ajax.d.ts

@@ -0,0 +1,3 @@
+import type { ServerlessContext, ServerlessSetup } from '../serverlessTypes.js';
+declare const Ajax: (context: ServerlessContext, setupServerless: ServerlessSetup) => Promise<Response>;
+export { Ajax };

package/lib/serverless/Ajax/Ajax.js

@@ -0,0 +1 @@
+import{ResponseError}from"../../utils/ResponseError/ResponseError.js";import{applyFilters}from"../../utils/filter/filter.js";import{isObjectStrict}from"../../utils/object/object.js";import{isStringStrict}from"../../utils/string/string.js";import{isNumber}from"../../utils/number/number.js";import{isFunction}from"../../utils/function/function.js";import{print}from"../../utils/print/print.js";import{config}from"../../config/config.js";import{serverlessActions}from"../serverless.js";const Ajax=async(context,setupServerless)=>{try{await setupServerless(context,"ajax");const request=context.request,data=await request.json();if(!isObjectStrict(data))throw new Error("Data not an object");const honeypotName=`${config.namespace}_asi`;if(isObjectStrict(data.inputs?.[honeypotName])){const honeypotValue=data.inputs[honeypotName].value;if(isStringStrict(honeypotValue)){const options={status:200,headers:{"Content-Type":"application/json"}};return new Response(JSON.stringify({success:"Form successully sent"}),options)}data.inputs[honeypotName].exclude=!0}const action=data.action;if(!isStringStrict(action))throw new Error("No action");let res=null;const ajaxFn=serverlessActions[action];isFunction(ajaxFn)&&(res=await ajaxFn(data,context));const ajaxResultFilterArgs={data:data,context:context};if(res=await applyFilters("ajaxResult",res,ajaxResultFilterArgs,!0),!res)throw new Error("No result");if(res.error)throw new ResponseError(res.error.message,res.error.response);const options={status:200,headers:{"Content-Type":"application/json"}};let message="";if(res.success){const{message:successMessage,headers:headers}=res.success;isStringStrict(successMessage)&&(message=successMessage),isObjectStrict(headers)&&(options.headers={...options.headers,...headers})}return new Response(JSON.stringify({success:message}),options)}catch(error){print("[FRM] Error with ajax function",error);let statusCode=500,message=error instanceof Error?error.message:"Unknown error";error instanceof ResponseError&&(isNumber(error.response?.status)&&(statusCode=error.response.status),isStringStrict(error.message)&&(message=error.message));const options={status:statusCode,headers:{"Content-Type":"application/json"}};return new Response(JSON.stringify({error:message}),options)}};export{Ajax};

package/lib/serverless/Ajax/AjaxTypes.d.ts

@@ -0,0 +1,11 @@
+import type { GenericStrings } from '../../global/globalTypes.js';
+import type { ServerlessActionData, ServerlessContext, ServerlessActionReturn } from '../serverlessTypes.js';
+export interface AjaxResultOptions {
+    status: number;
+    headers?: GenericStrings;
+}
+export interface AjaxResultFilterArgs {
+    data: ServerlessActionData;
+    context: ServerlessContext;
+}
+export type AjaxResultFilter = (res: ServerlessActionReturn | null, args: AjaxResultFilterArgs) => Promise<ServerlessActionReturn | null>;

package/lib/serverless/Ajax/AjaxTypes.js

@@ -0,0 +1 @@
+export{};

package/lib/serverless/Contact/Contact.d.ts

@@ -0,0 +1,3 @@
+import type { ServerlessAction } from '../serverlessTypes.js';
+declare const Contact: ServerlessAction;
+export { Contact };

package/lib/serverless/Contact/Contact.js

@@ -0,0 +1 @@
+import{config}from"../../config/config.js";import{escape}from"../../utils/escape/escape.js";import{isArray}from"../../utils/array/array.js";import{isString,isStringStrict}from"../../utils/string/string.js";import{isObject,isObjectStrict}from"../../utils/object/object.js";import{isBoolean}from"../../utils/boolean/boolean.js";import{getObjectKeys}from"../../utils/object/objectUtils.js";import{applyFilters}from"../../utils/filter/filter.js";import{getPermalink}from"../../utils/link/link.js";import{getStoreItem}from"../../store/store.js";import{minify}from"../../utils/minify/minify.js";const recurseEmailHtml=(data,output,depth=1)=>{if(!isObject(data))return;const isArr=isArray(data);getObjectKeys(data).forEach((label=>{const value=data[label],l=label.toString(),h=depth+1;1===depth&&(output.html+='\n        <tr>\n          <td style="padding: 16px 0; border-bottom: 2px solid #ccc;">\n      '),label&&!isArr&&(output.html+=`\n        <h${h} style="font-family: sans-serif; color: #222; margin: 16px 0; line-height: 1.3em">\n          ${l}\n        </h${h}>\n      `,output.plain+=`${l}\n`),recurseEmailHtml(value,output,depth+1),isString(value)&&(output.html+=`\n        <p style="font-family: sans-serif; color: #222; margin: 16px 0; line-height: 1.5em;">\n          ${value}\n        </p>\n      `,output.plain+=value.replace(/<br\s*\/?>/gi,"\n").replace(/(<([^>]+)>)/gi,"")+"\n"),1===depth&&(output.html+="\n          </td>\n        </tr>\n      ",output.plain+="\n")}))},Contact=async args=>{const{id:id,action:action,inputs:inputs}=args;if(!isStringStrict(id))return{error:{message:"No id"}};if(!isObjectStrict(inputs)||!Object.keys(inputs).length)return{error:{message:"No inputs"}};const formMetaData=getStoreItem("formMeta");if(!isObjectStrict(formMetaData))return{error:{message:"No meta"}};const meta=formMetaData[id];if(!isObjectStrict(meta))return{error:{message:"No meta object"}};const toEmail=meta.toEmail;if(!isStringStrict(toEmail))return{error:{message:"No to email"}};const toEmails=toEmail.split(","),senderEmail=meta.senderEmail;if(!isStringStrict(senderEmail))return{error:{message:"No sender email"}};let subject=isStringStrict(meta.subject)?meta.subject:"",replyToEmail="";const header=`${config.title} contact form submission`,footer=`This email was sent from a contact form on ${config.title} (${getPermalink()})`,outputData={},output={html:"",plain:""};for(const[name,input]of Object.entries(inputs)){const inputExclude=input.exclude;if(!!isBoolean(inputExclude)&&inputExclude)continue;const inputType=input.type,inputLabel=input.label.trim(),inputValue=input.value;let inputValueStr="";if(isArray(inputValue)&&(inputValueStr=inputValue.map((v=>escape(v.trim()+""))).join("<br>")),isString(inputValue)&&(inputValueStr=escape(inputValue.trim()+"")),"subject"===name){subject=inputValueStr?`${isStringStrict(subject)?`${subject} - `:""}${inputValueStr}`:subject;continue}"email"===inputType&&inputValueStr&&(replyToEmail=inputValueStr,inputValueStr=`<a href="mailto:${inputValueStr}">${inputValueStr}</a>`);const outputValue=""===inputValueStr?"--":inputValueStr;let hasLegend=!1,legend="";if(isStringStrict(input.legend)&&(hasLegend=!0,legend=input.legend),hasLegend){null==outputData[legend]&&(outputData[legend]={});null==outputData[legend][inputLabel]&&(outputData[legend][inputLabel]=[]),outputData[legend][inputLabel].push(outputValue)}if(!hasLegend){null==outputData[inputLabel]&&(outputData[inputLabel]=[]),outputData[inputLabel].push(outputValue)}}recurseEmailHtml(outputData,output);const outputHtml=`\n    <table width="100%" cellpadding="0" cellspacing="0" border="0">\n      <tr>\n        <td align="center" width="100%" style="padding: 0 16px 16px 16px;">\n          <table align="center" cellpadding="0" cellspacing="0" border="0" style="margin-right: auto; margin-left: auto; border-spacing: 0; max-width: 37.5em;">\n            <tr>\n              <td style="padding: 32px 0 0 0;">\n                <h1 style="font-family: sans-serif; color: #222; margin: 0; line-height: 1.3em;">\n                  ${header}\n                </h1>\n              </td>\n            </tr>\n            <tr>\n              <td>\n                <table border="0" cellpadding="0" cellspacing="0" width="100%" style="border-collapse: collapse;">\n                  ${output.html}\n                  <tr>\n                    <td style="padding: 32px 0;">\n                      <p style="font-family: sans-serif; color: #222; margin: 0; line-height: 1.5em;">\n                        ${footer}\n                      </p>\n                    </td>\n                  </tr>\n                </table>\n              </td>\n            </tr>\n          </table>\n        </td>\n      </tr>\n    </table>\n  `,outputPlain=`${header}\n\n${output.plain}${footer}`;subject||(subject=`${config.title} Contact Form`);const body={id:id,action:action,inputs:inputs,to:toEmails,sender:senderEmail,subject:subject,text:minify(outputPlain),html:minify(outputHtml)};return replyToEmail&&(body.replyTo=replyToEmail),await applyFilters("contactResult",{},body,!0)};export{Contact};

package/lib/serverless/Contact/ContactTypes.d.ts

@@ -0,0 +1,13 @@
+import type { ServerlessActionData, ServerlessActionReturn } from '../serverlessTypes.js';
+export interface ContactData {
+    [key: string]: string[] | ContactData;
+}
+export interface ContactBody extends ServerlessActionData {
+    to: string[];
+    sender: string;
+    subject: string;
+    text: string;
+    html: string;
+    replyTo?: string;
+}
+export type ContactResultFilter = (res: ServerlessActionReturn | null, args: ContactBody) => Promise<ServerlessActionReturn | null>;

package/lib/serverless/Contact/ContactTypes.js

@@ -0,0 +1 @@
+export{};

package/lib/serverless/Preview/Preview.d.ts

@@ -0,0 +1,5 @@
+import type { ServerlessContext, ServerlessSetup } from '../serverlessTypes.js';
+import type { getAllContentfulData } from '../../contentful/contentfulData.js';
+import type { getAllWordPressData } from '../../wordpress/wordpressData.js';
+declare const Preview: (context: ServerlessContext, setupServerless: ServerlessSetup, getData: typeof getAllContentfulData | typeof getAllWordPressData) => Promise<Response>;
+export { Preview };

package/lib/serverless/Preview/Preview.js

@@ -0,0 +1 @@
+import{isStringStrict}from"../../utils/string/string.js";import{isObjectStrict}from"../../utils/object/object.js";import{isFunction}from"../../utils/function/function.js";import{render,renderHttpError}from"../../render/render.js";import{minify}from"../../utils/minify/minify.js";const Preview=async(context,setupServerless,getData)=>{const{request:request,next:next}=context,{searchParams:searchParams}=new URL(request.url),contentType=searchParams.get("content_type"),id=searchParams.get("preview");if(!isStringStrict(id)||!isStringStrict(contentType))return next();await setupServerless(context,"preview");const previewData={id:id,contentType:contentType},data=await render({previewData:previewData,allData:await getData({previewData:previewData})});let html="",status=200;isObjectStrict(data)&&(html=data.output);const isEmpty=""===html;return isEmpty&&(status=404),isEmpty&&isFunction(renderHttpError)&&(html=await renderHttpError({code:status})),new Response(minify(html),{status:status,headers:{"Content-Type":"text/html;charset=UTF-8"}})};export{Preview};

package/lib/serverless/Reload/Reload.d.ts

@@ -0,0 +1,5 @@
+import type { ServerlessContext, ServerlessSetup } from '../serverlessTypes.js';
+import type { getAllContentfulData } from '../../contentful/contentfulData.js';
+import type { getAllWordPressData } from '../../wordpress/wordpressData.js';
+declare const Reload: (context: ServerlessContext, setupServerless: ServerlessSetup, getData: typeof getAllContentfulData | typeof getAllWordPressData) => Promise<Response>;
+export { Reload };

package/lib/serverless/Reload/Reload.js

@@ -0,0 +1 @@
+import{isStringStrict}from"../../utils/string/string.js";import{isObjectStrict}from"../../utils/object/object.js";import{isFunction}from"../../utils/function/function.js";import{render,renderHttpError}from"../../render/render.js";import{minify}from"../../utils/minify/minify.js";import{print}from"../../utils/print/print.js";const getErrorHtml=async(context,setupServerless,status)=>{try{if(await setupServerless(context,"error"),isFunction(renderHttpError))return await renderHttpError({code:status})}catch(error){print("[FRM] Error rendering http error",error)}return""},Reload=async(context,setupServerless,getData)=>{try{const{request:request,next:next}=context,{searchParams:searchParams,pathname:pathname}=new URL(request.url),page=searchParams.get("page"),filters=searchParams.get("filters"),path=pathname,query={};let noPage=!1,noFilters=!1;if(isStringStrict(page)?query.page=page:noPage=!0,isStringStrict(filters)?query.filters=filters:noFilters=!0,noPage&&noFilters)return next();await setupServerless(context,"reload");const serverlessData={query:query,path:path},data=await render({serverlessData:serverlessData,allData:await getData({serverlessData:serverlessData})});let html="",status=200;isObjectStrict(data)&&(html=data.output);const isEmpty=""===html;return isEmpty&&(status=404),isEmpty&&isFunction(renderHttpError)&&(html=await renderHttpError({code:status})),new Response(minify(html),{status:status,headers:{"Content-Type":"text/html;charset=UTF-8"}})}catch(error){print("[FRM] Error with reload function",error);const status=500,html=await getErrorHtml(context,setupServerless,status);return new Response(html,{status:status,headers:{"Content-Type":"text/html;charset=UTF-8"}})}};export{Reload};

package/lib/serverless/Reload/ReloadTypes.d.ts

@@ -0,0 +1,5 @@
+import type { Generic } from '../../global/globalTypes.js';
+export interface ReloadQuery extends Generic {
+    page?: string;
+    filters?: string;
+}

package/lib/serverless/Reload/ReloadTypes.js

@@ -0,0 +1 @@
+export{};

package/lib/serverless/serverless.d.ts

@@ -0,0 +1,6 @@
+import type { ServerlessRoutes, ServerlessActions, ServerlessArgs } from './serverlessTypes.js';
+declare let serverlessDir: string;
+declare let serverlessRoutes: ServerlessRoutes;
+declare let serverlessActions: ServerlessActions;
+declare const setServerless: (args: ServerlessArgs, dir?: string) => boolean;
+export { serverlessDir, serverlessRoutes, serverlessActions, setServerless };

package/lib/serverless/serverless.js

@@ -0,0 +1 @@
+import{isStringStrict}from"../utils/string/string.js";import{isObjectStrict}from"../utils/object/object.js";let serverlessDir="functions",serverlessRoutes={reload:[]},serverlessActions={};const setServerless=(args,dir="functions")=>{if(!isObjectStrict(args))return!1;const{actions:actions,routes:routes}=args;return isObjectStrict(actions)&&(serverlessActions={...actions}),isObjectStrict(routes)&&(serverlessRoutes={reload:[],...routes}),isStringStrict(dir)&&(serverlessDir=dir),!0};export{serverlessDir,serverlessRoutes,serverlessActions,setServerless};

package/lib/serverless/serverlessFiles.d.ts

@@ -0,0 +1,3 @@
+import type { ServerlessFilesArgs } from './serverlessTypes.js';
+declare const createServerlessFiles: (args?: ServerlessFilesArgs) => Promise<void>;
+export { createServerlessFiles };

package/lib/serverless/serverlessFiles.js

@@ -0,0 +1 @@
+import{mkdir,writeFile}from"node:fs/promises";import{resolve,dirname}from"node:path";import{getPathDepth}from"../utils/path/path.js";import{isObjectStrict}from"../utils/object/object.js";import{isArrayStrict}from"../utils/array/array.js";import{isStringStrict}from"../utils/string/string.js";import{dataSource}from"../utils/dataSource/dataSource.js";import{print}from"../utils/print/print.js";import{config}from"../config/config.js";import{serverlessDir,serverlessRoutes}from"./serverless.js";const minify=str=>str.replace(/\s+/g," ").replace(/;\s*}/g,";}").trim(),createServerlessFiles=async args=>{let defaultDataExport="getAllContentfulData",defaultDataFile="@alanizcreative/formation-static/contentful/contentfulData.js";dataSource.isWordPress()&&(defaultDataExport="getAllWordPressData",defaultDataFile="@alanizcreative/formation-static/wordpress/wordpressData.js");const defaults={dataExport:defaultDataExport,dataExportFile:defaultDataFile,setupExport:"setupServerless",setupExportFile:"lib/setup/setupServerless.js",previewExportFile:"@alanizcreative/formation-static/serverless/Preview/Preview.js",reloadExportFile:"@alanizcreative/formation-static/serverless/Reload/Reload.js",ajaxExportFile:"@alanizcreative/formation-static/serverless/Ajax/Ajax.js",ajaxFile:"ajax/index.js",previewFile:"_middleware.js",reloadFile:"_middleware.js"},{dataExport:dataExport,dataExportFile:dataExportFile,setupExport:setupExport,setupExportFile:setupExportFile,previewExportFile:previewExportFile,reloadExportFile:reloadExportFile,ajaxExportFile:ajaxExportFile,ajaxFile:ajaxFile,previewFile:previewFile,reloadFile:reloadFile}=Object.assign(defaults,isObjectStrict(args)?args:{});if(await mkdir(resolve(serverlessDir),{recursive:!0}),isStringStrict(ajaxFile)){const pathDepth=getPathDepth(`${serverlessDir}/${ajaxFile}`),content=`import { Ajax } from '${ajaxExportFile.startsWith("@")?"":pathDepth}${ajaxExportFile}';\nimport { ${setupExport} } from '${pathDepth}${setupExportFile}';\nconst render = async (context) => {\n  return await Ajax(context, ${setupExport});\n};\nexport const onRequestPost = [render];`,path=resolve(serverlessDir,ajaxFile),dir=dirname(path);await mkdir(resolve(serverlessDir,dir),{recursive:!0}),await writeFile(path,minify(content)),print("[FRM] Successfully wrote",path,"success")}if(config.env.dev&&isStringStrict(previewFile)){const pathDepth=getPathDepth(`${serverlessDir}/${previewFile}`),content=`import { Preview } from '${previewExportFile.startsWith("@")?"":pathDepth}${previewExportFile}';\nimport { ${dataExport} } from '${dataExportFile.startsWith("@")?"":pathDepth}${dataExportFile}';\nimport { ${setupExport} } from '${pathDepth}${setupExportFile}';\nconst render = async (context) => {\n  return await Preview(context, ${setupExport}, ${dataExport});\n};\nexport const onRequestGet = [render];`,path=resolve(serverlessDir,previewFile),dir=dirname(path);await mkdir(resolve(serverlessDir,dir),{recursive:!0}),await writeFile(path,minify(content)),print("[FRM] Successfully wrote",path,"success")}const newRoutes=[],hasReloadFile=isStringStrict(reloadFile);for(const[type,routes]of Object.entries(serverlessRoutes))if(isArrayStrict(routes))for(const route of routes){let{path:path,content:content}=route;if(isStringStrict(path)){if("reload"===type&&hasReloadFile){path=`${path}/${reloadFile}`;const pathDepth=getPathDepth(`${serverlessDir}/${path}`);content=`import { Reload } from '${reloadExportFile.startsWith("@")?"":pathDepth}${reloadExportFile}';\nimport { ${dataExport} } from '${dataExportFile.startsWith("@")?"":pathDepth}${dataExportFile}';\nimport { ${setupExport} } from '${pathDepth}${setupExportFile}';\nconst render = async (context) => {\n  return await Reload(context, ${setupExport}, ${dataExport});\n};\nexport const onRequestGet = [render];`}isStringStrict(content)&&newRoutes.push({path:path,content:content})}}for(const route of newRoutes){const{path:path,content:content}=route,newPath=resolve(serverlessDir,path),dir=dirname(newPath);await mkdir(resolve(serverlessDir,dir),{recursive:!0}),await writeFile(newPath,content),print("[FRM] Successfully wrote",newPath,"success")}};export{createServerlessFiles};

package/lib/serverless/serverlessTypes.d.ts

@@ -0,0 +1,50 @@
+import type { EventContext } from '@cloudflare/workers-types';
+import type { Generic, GenericStrings } from '../global/globalTypes.js';
+export interface ServerlessRoute {
+    path: string;
+    content?: string;
+}
+export type ServerlessRoutes = Record<string, ServerlessRoute[]>;
+export type ServerlessContext = EventContext<GenericStrings, string, unknown>;
+export type ServerlessSetup = (context: ServerlessContext, type?: string) => Promise<void> | void;
+export interface ServerlessActionInput extends Generic {
+    type: string;
+    label: string;
+    value: string | string[];
+    legend?: string;
+    exclude?: boolean;
+}
+export interface ServerlessActionData {
+    id: string;
+    action: string;
+    inputs: Record<string, ServerlessActionInput>;
+}
+export interface ServerlessActionReturn {
+    error?: {
+        message: string;
+        response?: Response;
+    };
+    success?: {
+        message: string;
+        headers?: GenericStrings;
+    };
+}
+export type ServerlessAction = (args: ServerlessActionData, context: ServerlessContext) => Promise<ServerlessActionReturn>;
+export type ServerlessActions = Record<string, ServerlessAction>;
+export interface ServerlessFilesArgs {
+    dataExport?: string;
+    dataExportFile?: string;
+    setupExport?: string;
+    setupExportFile?: string;
+    previewExportFile?: string;
+    reloadExportFile?: string;
+    ajaxExportFile?: string;
+    ajaxFile?: string;
+    previewFile?: string;
+    reloadFile?: string;
+    setupFile?: string;
+}
+export interface ServerlessArgs {
+    actions?: ServerlessActions;
+    routes?: ServerlessRoutes;
+}

package/lib/serverless/serverlessTypes.js

@@ -0,0 +1 @@
+export{};

package/lib/store/store.d.ts

@@ -0,0 +1,9 @@
+import type { Store } from './storeTypes.js';
+import type { RenderAllData } from '../render/renderTypes.js';
+declare let storeDir: string;
+declare let store: Store;
+declare const setStore: <T extends object>(args: T, dir?: string) => Store & T;
+declare const setStoreItem: <T extends Store, K extends keyof T, V extends keyof T[K] | undefined = undefined>(prop: K, value: V extends keyof T[K] ? T[K][V] : T[K], subProp?: V) => boolean;
+declare const setStoreData: (allData: RenderAllData) => boolean;
+declare const getStoreItem: <T extends Store, K extends keyof T>(prop: K) => T[K];
+export { store, storeDir, setStore, setStoreData, setStoreItem, getStoreItem };

package/lib/store/store.js

@@ -0,0 +1 @@
+import{normalizeContentType}from"../utils/contentType/contentType.js";import{isObject,isObjectStrict}from"../utils/object/object.js";import{isStringStrict}from"../utils/string/string.js";import{isArrayStrict}from"../utils/array/array.js";import{config}from"../config/config.js";let storeDir="lib/store";const defaultStore={slugs:{},parents:{},navigations:[],navigationItems:[],formMeta:{},archiveMeta:{},imageMeta:{},taxonomies:{}};let store={...defaultStore};const setStore=(args,dir="lib/store")=>isObjectStrict(args)?(store={...defaultStore,...args},isStringStrict(dir)&&(storeDir=dir),store):store,setStoreItem=(prop,value,subProp)=>!(!isStringStrict(prop)||!isObject(value)||null==store[prop])&&(isStringStrict(subProp)?store[prop][subProp]=value:store[prop]=value,!0),setStoreData=allData=>{if(!isObjectStrict(allData))return!1;const{navigation:navigation,navigationItem:navigationItem,content:content}=allData;store.navigations=isArrayStrict(navigation)?navigation:[],store.navigationItems=isArrayStrict(navigationItem)?navigationItem:[];const data={...allData,...content};return config.hierarchicalTypes.forEach((type=>{const items=data[type];isArrayStrict(items)&&items.forEach((item=>{if(!isObjectStrict(item))return;const{id:id,parent:parent,archive:archive,slug:slug,title:title}=item;if(!isStringStrict(id))return;const archiveType=normalizeContentType(archive);if(isStringStrict(archiveType)){const archiveObj=isObjectStrict(store.archiveMeta[archiveType])?store.archiveMeta[archiveType]:{};store.archiveMeta[archiveType]={id:id,slug:slug,title:title,contentType:type,...archiveObj}}if(isObjectStrict(parent)){const parentSlug=parent.slug,parentTitle=parent.title,parentId=parent.id;isStringStrict(parentSlug)&&isStringStrict(parentTitle)&&isStringStrict(parentId)&&(null==store.parents[type]&&(store.parents[type]={}),store.parents[type][id]={id:parentId,slug:parentSlug,title:parentTitle})}}))})),!0},getStoreItem=prop=>store[prop];export{store,storeDir,setStore,setStoreData,setStoreItem,getStoreItem};

package/lib/store/storeFiles.d.ts

@@ -0,0 +1,2 @@
+declare const createStoreFiles: () => Promise<void>;
+export { createStoreFiles };

package/lib/store/storeFiles.js

@@ -0,0 +1 @@
+import{mkdir,writeFile}from"node:fs/promises";import{resolve}from"node:path";import{print}from"../utils/print/print.js";import{storeDir,store}from"./store.js";const createStoreFiles=async()=>{await mkdir(resolve(storeDir),{recursive:!0});for(const[key,data]of Object.entries(store)){const path=resolve(storeDir,`${key}.json`);await writeFile(path,JSON.stringify(data)),print("[FRM] Successfully wrote",path,"success")}};export{createStoreFiles};

package/lib/store/storeTypes.d.ts

@@ -0,0 +1,35 @@
+import type { NavigationList, NavigationItem } from '../components/Navigation/NavigationTypes.js';
+import type { ImageProps } from '../utils/image/imageTypes.js';
+import type { FormMeta } from '../objects/Form/FormTypes.js';
+import type { Generic, Taxonomy } from '../global/globalTypes.js';
+export interface StoreSlug {
+    contentType: string;
+    id: string;
+}
+export interface StoreParent {
+    id: string;
+    slug: string;
+    title: string;
+}
+export interface StoreArchiveMeta {
+    id?: string;
+    slug?: string;
+    title?: string;
+    contentType?: string;
+    singular?: string;
+    plural?: string;
+    layout?: string;
+    order?: string;
+    display?: number;
+}
+export type StoreImageMeta = Record<string, ImageProps>;
+export interface Store extends Generic {
+    slugs: Record<string, StoreSlug>;
+    parents: Record<string, Record<string, StoreParent>>;
+    archiveMeta: Record<string, StoreArchiveMeta>;
+    formMeta: Record<string, FormMeta>;
+    imageMeta: StoreImageMeta;
+    navigations: NavigationList[];
+    navigationItems: NavigationItem[];
+    taxonomies: Record<string, Taxonomy>;
+}

package/lib/store/storeTypes.js

@@ -0,0 +1 @@
+export{};

package/lib/text/RichText/RichText.d.ts

@@ -0,0 +1,4 @@
+import type { RichTextProps, RichTextContent } from './RichTextTypes.js';
+declare const getPlainText: (args: RichTextContent | RichTextContent[] | string | undefined, _output?: string) => string;
+declare const RichText: (props: RichTextProps) => string;
+export { RichText, getPlainText };

package/lib/text/RichText/RichText.js

@@ -0,0 +1 @@
+import{getLink}from"../../utils/link/link.js";import{getExcerpt}from"../../utils/excerpt/excerpt.js";import{applyFilters}from"../../utils/filter/filter.js";import{isString,isStringStrict}from"../../utils/string/string.js";import{isArray,isArrayStrict}from"../../utils/array/array.js";import{isObjectStrict}from"../../utils/object/object.js";import{isHeading}from"../../utils/heading/heading.js";const containsShortcode=(tag,content)=>"p"===tag&&"["===content.charAt(0)&&"]"===content.charAt(content.length-1),addDataAttr=(dataAttr=!0,tag="")=>isArrayStrict(dataAttr)?dataAttr.includes(tag):dataAttr,getContent=args=>{const{content:content=[],props:props,dataAttr:dataAttr=!1}=args;let{_output:_output=""}=args;for(const item of content){const newItem=applyFilters("richTextContentItem",item,props),itemObj=isObjectStrict(newItem)?newItem:{},{link:link,attr:attr,internalLink:internalLink,content:itemContent}=itemObj;let{tag:tag=""}=itemObj,newContent=itemContent;const isSingleTag="br"===tag||"hr"===tag;isArrayStrict(itemContent)&&(newContent=getContent({content:itemContent,props:props,dataAttr:dataAttr}));const attrs=[];if(addDataAttr(dataAttr,tag)&&attrs.push(`data-rich="${tag}"`),isStringStrict(attr)&&attrs.push(attr),isObjectStrict(attr)&&Object.entries(attr).forEach((([key,value])=>{attrs.push(`${key}="${value}"`)})),"a"===tag){let anchorLink=link;internalLink&&(anchorLink=getLink(internalLink)),isStringStrict(anchorLink)&&attrs.push(`href="${anchorLink}"`)}let outputStr="";if(isString(newContent)){const filteredContent=applyFilters("richTextContent",newContent,{args:newItem,props:props});isString(filteredContent)&&(newContent=filteredContent),outputStr+=newContent}containsShortcode(tag,outputStr)&&(tag="");let opening="",closing="",inner="";isStringStrict(tag)&&outputStr.trim()&&!isSingleTag&&(opening=`<${tag}${attrs.length>0?` ${attrs.join(" ")}`:""}>`,closing=`</${tag}>`,inner=outputStr,outputStr=`${opening}${outputStr}${closing}`),isSingleTag&&(outputStr=`<${tag}>`);outputStr=applyFilters("richTextContentOutput",outputStr,{args:newItem,props:props,element:{opening:opening,closing:closing,content:inner}}),_output+=outputStr}return _output},getPlainText=(args,_output="")=>{if(isString(args))return args;const content=isObjectStrict(args)?args.content:args;if(!isArrayStrict(content))return _output;for(const item of content){const{content:itemContent}=isObjectStrict(item)?item:{};isString(itemContent)&&(_output+=itemContent),isArrayStrict(itemContent)&&(_output=getPlainText({content:itemContent},_output))}return _output},RichText=props=>{if(!isObjectStrict(props))return"";if(props=applyFilters("richTextProps",props),!isObjectStrict(props))return"";const{args:args}=props;if(!isObjectStrict(args))return"";const{content:content=[],classes:classes,link:link,internalLink:internalLink,textStyle:textStyle,headingStyle:headingStyle,align:align,style:style,attr:attr,dataAttr:dataAttr=!0}=args;let{tag:tag=""}=args;if("hr"===tag||"br"===tag)return`<${tag}>`;const isSectionHeading=isHeading(tag),classesArr=[];isStringStrict(classes)&&classesArr.push(classes),isStringStrict(textStyle)&&classesArr.push(textStyle),isStringStrict(headingStyle)&&isSectionHeading&&classesArr.push(headingStyle),isStringStrict(align)&&classesArr.push(align);const filterProps={...props};filterProps.args.content=void 0;let headingObj,output="",headingStr="";isStringStrict(content)&&(output=content,headingStr=content),isArrayStrict(content)&&(headingObj=content,output=getContent({content:content,props:filterProps,dataAttr:dataAttr}));const attrs=[];if(addDataAttr(dataAttr,tag)&&attrs.push(`data-rich="${tag}"`),isSectionHeading){const headingContents=getExcerpt({limit:10,limitExcerpt:!0,excerpt:headingStr,content:headingObj}),id=headingContents.trim().replace(/&hellip;/g,"").replace(/[^\w\s]|_/g,"").replace(/\s+/g,"-").toLowerCase();headingContents&&id&&(attrs.push(`id="${id}"`),isArray(props.headings)&&props.headings.push({id:id,title:headingContents,type:tag}))}if("a"===tag){let anchorLink=link;const inLink=getLink(internalLink);isStringStrict(inLink)&&(anchorLink=inLink),isStringStrict(anchorLink)&&attrs.push(`href="${anchorLink}"`)}classesArr.length>0&&attrs.push(`class="${classesArr.join(" ")}"`),isStringStrict(style)&&attrs.push(`style="${style}"`),isStringStrict(attr)&&attrs.push(attr),isObjectStrict(attr)&&Object.entries(attr).forEach((([key,value])=>{attrs.push(`${key}="${value}"`)})),containsShortcode(tag,output)&&(tag="");let opening="",closing="",inner="";isStringStrict(tag)&&output.trim()&&(opening=`<${tag}${attrs.length>0?` ${attrs.join(" ")}`:""}>`,closing=`</${tag}>`,inner=output,output=`${opening}${output}${closing}`);return output=applyFilters("richTextOutput",output,{props:filterProps,element:{opening:opening,closing:closing,content:inner}}),output};export{RichText,getPlainText};

package/lib/text/RichText/RichTextTypes.d.ts

@@ -0,0 +1,54 @@
+import type { InternalLink, Generic, GenericStrings } from '../../global/globalTypes.js';
+import type { RenderRichText, RenderFunctionArgs, RenderItem } from '../../render/renderTypes.js';
+export interface RichTextHeading {
+    title: string;
+    id: string;
+    type: string;
+}
+export interface RichTextElement {
+    opening: string;
+    content: string;
+    closing: string;
+}
+export interface RichTextArgs extends Generic {
+    tag?: string;
+    content?: RenderRichText[] | string;
+    classes?: string;
+    textStyle?: string;
+    headingStyle?: string;
+    caption?: RenderRichText[] | string;
+    align?: string;
+    link?: string;
+    internalLink?: InternalLink;
+    style?: string;
+    attr?: string | GenericStrings;
+    dataAttr?: boolean | string[];
+}
+export interface RichTextContent extends Generic {
+    content?: RenderRichText[] | string;
+}
+export interface RichTextProps<T = RichTextArgs, R = RenderItem> extends RenderFunctionArgs<T, R> {
+    args: RichTextArgs & T;
+}
+export interface RichTextContentProps {
+    content: RenderRichText[];
+    props: RichTextProps;
+    dataAttr: boolean | string[];
+    _output?: string;
+}
+export interface RichTextContentFilterArgs {
+    args: RenderRichText;
+    props: RichTextProps;
+}
+export interface RichTextContentOutputFilterArgs extends RichTextContentFilterArgs {
+    element: RichTextElement;
+}
+export interface RichTextOutputFilterArgs {
+    props: RichTextProps;
+    element: RichTextElement;
+}
+export type RichTextPropsFilter = (props: RichTextProps) => RichTextProps;
+export type RichTextOutputFilter = (output: string, args: RichTextContentOutputFilterArgs) => string;
+export type RichTextContentItemFilter = (item: RenderRichText, args: RichTextProps) => RenderRichText;
+export type RichTextContentFilter = (content: string, args: RichTextContentFilterArgs) => string;
+export type RichTextContentOutputFilter = (content: string, args: RichTextContentOutputFilterArgs) => string;

package/lib/text/RichText/RichTextTypes.js

@@ -0,0 +1 @@
+export{};

package/lib/utils/ResponseError/ResponseError.d.ts

@@ -0,0 +1,5 @@
+declare class ResponseError extends Error {
+    response: Response | undefined;
+    constructor(message: string, res?: Response);
+}
+export { ResponseError };

package/lib/utils/ResponseError/ResponseError.js

@@ -0,0 +1 @@
+class ResponseError extends Error{response;constructor(message,res){super(message),this.message=message,res instanceof Response&&(this.response=res)}}export{ResponseError};

package/lib/utils/action/action.d.ts

@@ -0,0 +1,8 @@
+import type { Actions, ActionMap, ActionReturnType } from './actionTypes.js';
+declare let actions: ActionMap;
+declare const addAction: <T extends keyof Actions>(name: T, action: Actions[T]) => boolean;
+declare const removeAction: <T extends keyof Actions>(name: T, action: Actions[T]) => boolean;
+declare const doActions: <V extends boolean = false>(name: string, args?: unknown, isAsync?: V) => ActionReturnType<V>;
+declare const resetActions: () => void;
+declare const setActions: (args: Partial<Actions>) => boolean;
+export { actions, addAction, removeAction, doActions, resetActions, setActions };

package/lib/utils/action/action.js

@@ -0,0 +1 @@
+import{isSet,isSetStrict}from"../set/set.js";import{isStringStrict}from"../string/string.js";import{isObjectStrict}from"../object/object.js";import{isFunction}from"../function/function.js";let actions=new Map([["renderStart",new Set],["renderEnd",new Set],["renderItemStart",new Set],["renderItemEnd",new Set]]);const addAction=(name,action)=>!(!isStringStrict(name)||!isFunction(action))&&(isSet(actions.get(name))||actions.set(name,new Set),actions.get(name)?.add(action),!0),removeAction=(name,action)=>{if(!isStringStrict(name)||!isFunction(action))return!1;const actionSet=actions.get(name);return!!isSet(actionSet)&&actionSet.delete(action)},doSequentially=async(callbacks,args)=>{for(const callback of callbacks)await callback(args)},doActions=(name,args,isAsync=!1)=>{const actionSet=actions.get(name);if(!isSetStrict(actionSet))return;const callbacks=[];for(const callback of actionSet.values())isAsync?callbacks.push(callback):callback(args);isAsync&&doSequentially(callbacks,args).then((result=>result)).catch((()=>!1))},resetActions=()=>{actions=new Map([["renderStart",new Set],["renderEnd",new Set],["renderItemStart",new Set],["renderItemEnd",new Set]])},setActions=args=>{if(!isObjectStrict(args))return!1;const newActions=Object.entries(args);return!!newActions.length&&(resetActions(),newActions.forEach((([name,action])=>{action&&addAction(name,action)})),!0)};export{actions,addAction,removeAction,doActions,resetActions,setActions};

package/lib/utils/action/actionTypes.d.ts

@@ -0,0 +1,10 @@
+import type { GenericFunction } from '../../global/globalTypes.js';
+import type { RenderStartAction, RenderEndAction, RenderItemStartAction, RenderItemEndAction } from '../../render/renderTypes.js';
+export interface Actions extends Record<string, GenericFunction> {
+    renderStart: RenderStartAction;
+    renderEnd: RenderEndAction;
+    renderItemStart: RenderItemStartAction;
+    renderItemEnd: RenderItemEndAction;
+}
+export type ActionMap = Map<string, Set<GenericFunction>> & Map<'renderStart' | 'renderEnd' | 'renderItemStart' | 'renderItemEnd', Set<RenderStartAction | RenderEndAction | RenderItemStartAction | RenderItemEndAction>>;
+export type ActionReturnType<V extends false | true> = V extends true ? Promise<void> : undefined;

package/lib/utils/action/actionTypes.js

@@ -0,0 +1 @@
+export{};

package/lib/utils/archive/archive.d.ts

@@ -0,0 +1,7 @@
+import type { ArchiveInfo, ArchiveTaxonomy, ArchiveLink, ArchiveLabels } from './archiveTypes.js';
+import type { RenderItem } from '../../render/renderTypes.js';
+declare const getArchiveInfo: (contentType: string) => ArchiveInfo;
+declare const getTaxonomyInfo: (contentType: string, pageData?: RenderItem) => ArchiveTaxonomy;
+declare const getArchiveLink: (contentType: string, pageData?: RenderItem) => ArchiveLink;
+declare const getArchiveLabels: (contentType: string, pageData?: RenderItem) => ArchiveLabels;
+export { getArchiveInfo, getTaxonomyInfo, getArchiveLink, getArchiveLabels };

package/lib/utils/archive/archive.js

@@ -0,0 +1 @@
+import{getStoreItem}from"../../store/store.js";import{isObjectStrict}from"../object/object.js";import{isArrayStrict}from"../array/array.js";import{isStringStrict}from"../string/string.js";import{isBoolean}from"../boolean/boolean.js";import{normalizeContentType}from"../contentType/contentType.js";import{getSlug,getPermalink}from"../link/link.js";const getArchiveInfo=contentType=>{const value={id:"",slug:"",title:"",contentType:""};if("page"===(contentType=normalizeContentType(contentType)))return value;const info=getStoreItem("archiveMeta")[contentType];if(!isObjectStrict(info))return value;const{id:id,slug:slug,title:title,contentType:type}=info;return value.id=isStringStrict(id)?id:"",value.slug=isStringStrict(slug)?slug:"",value.title=isStringStrict(title)?title:"",value.contentType=isStringStrict(type)?type:"",value},getTaxonomyInfo=(contentType,pageData)=>{const value={id:"",slug:"",title:"",contentTypes:[],primaryContentType:"",usePrimaryContentTypeSlug:!0,isPage:!1},taxObj="taxonomy"===contentType?pageData:pageData?.taxonomy;if(!isObjectStrict(taxObj))return value;const{id:id,slug:slug,link:link,title:title,contentTypes:contentTypes,usePrimaryContentTypeSlug:usePrimaryContentTypeSlug,isPage:isPage}=taxObj,taxonomyTypes=isArrayStrict(contentTypes)?contentTypes.map((type=>normalizeContentType(type))):[],primaryTaxonomyType=taxonomyTypes[0];return value.id=isStringStrict(id)?id:"",value.slug=isStringStrict(slug)?slug:"",value.title=isStringStrict(title)?title:"",value.contentTypes=taxonomyTypes,value.primaryContentType=isStringStrict(primaryTaxonomyType)?primaryTaxonomyType:"",value.usePrimaryContentTypeSlug=!isBoolean(usePrimaryContentTypeSlug)||usePrimaryContentTypeSlug,value.isPage=!!isBoolean(isPage)&&isPage,isStringStrict(link)&&(value.link=link),value},getArchiveLink=(contentType,pageData)=>{let slug,title="";const taxonomyInfo=getTaxonomyInfo(contentType,pageData),{title:taxonomyTitle,isPage:taxonomyIsPage,contentTypes:taxonomyTypes,usePrimaryContentTypeSlug:taxonomyUseTypeSlug}=taxonomyInfo;"term"===contentType&&taxonomyIsPage&&(slug=getSlug({slug:"",contentType:contentType,pageData:pageData}),title=taxonomyTitle);const taxonomyType=taxonomyTypes[0],useArchiveType=taxonomyUseTypeSlug&&isStringStrict(taxonomyType);"taxonomy"===contentType&&useArchiveType&&(contentType=taxonomyType),"term"===contentType&&!taxonomyIsPage&&useArchiveType&&(contentType=taxonomyType);const archiveInfo=getArchiveInfo(contentType),{id:archiveId,slug:archiveSlug,title:archiveTitle,contentType:archiveType}=archiveInfo;if(archiveSlug&&archiveId){slug=getSlug({id:archiveId,slug:archiveSlug,contentType:archiveType});const plural=getStoreItem("archiveMeta")[contentType]?.plural;title=isStringStrict(plural)?plural:archiveTitle}return{title:title,link:isStringStrict(slug)?getPermalink(slug):""}},getArchiveLabels=(contentType,pageData)=>{let singular="Post",plural="Posts";const taxonomyInfo=getTaxonomyInfo(contentType,pageData),{title:taxonomyTitle,isPage:taxonomyIsPage,primaryContentType:taxonomyType,usePrimaryContentTypeSlug:taxonomyUseTypeSlug}=taxonomyInfo;if("term"===contentType&&taxonomyIsPage&&isStringStrict(taxonomyTitle))return{singular:taxonomyTitle,plural:taxonomyTitle};const useArchiveType=taxonomyUseTypeSlug&&isStringStrict(taxonomyType);if("taxonomy"===contentType&&useArchiveType&&(contentType=taxonomyType),"term"===contentType&&!taxonomyIsPage&&useArchiveType&&(contentType=taxonomyType),isStringStrict(contentType)){contentType=normalizeContentType(contentType);const archiveType=getStoreItem("archiveMeta")[contentType],s=archiveType?.singular,p=archiveType?.plural;singular=isStringStrict(s)?s:"Post",plural=isStringStrict(p)?p:"Posts"}return{singular:singular,plural:plural}};export{getArchiveInfo,getTaxonomyInfo,getArchiveLink,getArchiveLabels};

package/lib/utils/archive/archiveTypes.d.ts

@@ -0,0 +1,18 @@
+import type { Taxonomy } from '../../global/globalTypes.js';
+export interface ArchiveInfo {
+    id: string;
+    slug: string;
+    title: string;
+    contentType: string;
+}
+export interface ArchiveTaxonomy extends Omit<Required<Taxonomy>, 'link'>, Pick<Taxonomy, 'link'> {
+    primaryContentType: string;
+}
+export interface ArchiveLink {
+    title: string;
+    link: string;
+}
+export interface ArchiveLabels {
+    singular: string;
+    plural: string;
+}

package/lib/utils/archive/archiveTypes.js

@@ -0,0 +1 @@
+export{};

package/lib/utils/array/array.d.ts

@@ -0,0 +1,3 @@
+declare const isArray: (value: unknown) => value is unknown[];
+declare const isArrayStrict: (value: unknown) => value is unknown[];
+export { isArray, isArrayStrict };

package/lib/utils/array/array.js

@@ -0,0 +1 @@
+const isArray=value=>Array.isArray(value),isArrayStrict=value=>isArray(value)&&value.length>0;export{isArray,isArrayStrict};

package/lib/utils/boolean/boolean.d.ts

@@ -0,0 +1,2 @@
+declare const isBoolean: (value: unknown) => value is boolean;
+export { isBoolean };