@alanizcreative/formation-static 0.0.1

package/lib/objects/Form/FormField.js

@@ -0,0 +1 @@
+import{v4 as uuid}from"uuid";import{applyFilters}from"../../filters/filters.js";import{isStringStrict}from"../../utils/string/string.js";import{isObjectStrict}from"../../utils/object/object.js";const FormField=props=>{if(!isObjectStrict(props))return[];props=applyFilters("formFieldProps",props);const{args:args}=props,{type:type="text",name:name,label:label,hint:hint,value:value,required:required=!1,attr:attr,emptyError:emptyError,invalidError:invalidError,fieldTag:fieldTag="div",fieldClasses:fieldClasses,fieldAttr:fieldAttr,fieldsetClasses:fieldsetClasses,fieldsetAttr:fieldsetAttr,labelClasses:labelClasses,classes:classes,radioIcon:radioIcon,checkboxIcon:checkboxIcon}=isObjectStrict(args)?args:{},isHidden="hidden"===type;if(!isStringStrict(label)&&!isHidden)return[];let isFieldset="fieldset"===type;if(!isFieldset&&!isStringStrict(name))return[];const isOption="checkbox"===type||"radio"===type,isSelect="select"===type;("checkbox-group"===type||"radio-group"===type)&&(isFieldset=!0);const isTextarea="textarea"===type,hasValue=isStringStrict(value),id=uuid();let optionIcon="",selectIcon="";"radio"===type&&isStringStrict(radioIcon)&&(optionIcon=radioIcon),"checkbox"===type&&isStringStrict(checkboxIcon)&&(optionIcon=checkboxIcon),"select"===type&&isStringStrict(args.selectIcon)&&(selectIcon=args.selectIcon);const requiredIcon=required&&isStringStrict(args.requiredIcon)?args.requiredIcon:"",fieldAttrs=["data-form-field"],fieldsetAttrs=[],attrs=["data-form-input"];if(isStringStrict(attr)){const attrsArr=attr.split("\n");for(const attrItem of attrsArr){const[attrName,attrValue]=attrItem.split(" : ");isStringStrict(attrName)&&isStringStrict(attrValue)&&attrs.push(`${attrName}="${attrValue}"`)}}isTextarea||isSelect||!hasValue||attrs.push(`value="${value}"`),isStringStrict(classes)&&attrs.push(`class="${classes}"`),isStringStrict(fieldClasses)&&fieldAttrs.push(`class="${fieldClasses}"`),isStringStrict(fieldsetClasses)&&fieldsetAttrs.push(`class="${fieldsetClasses}"`),isStringStrict(fieldAttr)&&fieldAttrs.push(fieldAttr),isStringStrict(fieldsetAttr)&&fieldsetAttrs.push(fieldsetAttr),isStringStrict(emptyError)&&!isHidden&&(isFieldset?fieldsetAttrs:attrs).push(`data-form-empty="${emptyError}"`),isStringStrict(invalidError)&&!isHidden&&(isFieldset?fieldsetAttrs:attrs).push(`data-form-invalid="${invalidError}"`),required&&!isHidden&&(isFieldset?fieldsetAttrs:attrs).push(isFieldset?"data-form-required":"required");const fieldAtts=` ${fieldAttrs.join(" ")}`,fieldsetAtts=fieldsetAttrs.length?` ${fieldsetAttrs.join(" ")}`:"",atts=` ${attrs.join(" ")}`;let hintOutput="";isStringStrict(hint)&&(hintOutput=`<small data-form-hint>${hint}</small>`);let labelBefore="",labelAfter="";const labelClass=isStringStrict(labelClasses)?` class="${labelClasses}"`:"";isFieldset?labelBefore=`\n      <legend id="${uuid()}"${labelClass}>\n        <span data-form-legend>\n          <span data-form-legend-text>${label}</span>\n          ${requiredIcon}\n        </span>\n        ${hintOutput}\n      </legend>\n    `:isOption?labelAfter=`\n      <label for="${id}"${labelClass}>\n        <span data-form-option>\n          ${optionIcon}\n          <span data-form-label>\n            <span data-form-label-text>${label}</span>\n            ${requiredIcon}\n          </span>\n        </span>\n        ${hintOutput}\n      </label>\n    `:labelBefore=`\n      <label for="${id}"${labelClass}>\n        <span data-form-label>\n          <span data-form-label-text>${label}</span>\n          ${requiredIcon}\n        </span>\n        ${hintOutput}\n      </label>\n    `;let beforeOutput="",afterOutput="";switch(type){case"text":case"email":case"checkbox":case"radio":case"number":case"password":case"tel":case"url":case"hidden":beforeOutput=`<input type="${type}" name="${name}" id="${id}"${atts}>`;break;case"textarea":beforeOutput=`<textarea name="${name}" id="${id}"${atts}>${hasValue?value:""}</textarea>`;break;case"select":beforeOutput=`\n        <div data-form-select>\n          <select name="${name}" id="${id}"${atts}>`,afterOutput=`\n          </select>\n          ${selectIcon}\n        </div>`}return isHidden?[beforeOutput]:[`\n    <${fieldTag}${fieldAtts}>\n      ${isFieldset?`<fieldset${fieldsetAtts}>`:""}\n      ${labelBefore}\n      ${isFieldset?"<div data-form-group>":""}\n      ${beforeOutput}`,`${afterOutput}\n      ${labelAfter}\n      ${isFieldset?"</div></fieldset>":""}\n    </${fieldTag}>\n  `]};export{FormField};

package/lib/objects/Form/FormOption.d.ts

@@ -0,0 +1,3 @@
+import type { FormOptionProps } from './FormTypes.js';
+declare const FormOption: (props: FormOptionProps) => string;
+export { FormOption };

package/lib/objects/Form/FormOption.js

@@ -0,0 +1 @@
+import{v4 as uuid}from"uuid";import{applyFilters}from"../../filters/filters.js";import{isStringStrict}from"../../utils/string/string.js";import{isObjectStrict}from"../../utils/object/object.js";import{isArrayStrict}from"../../utils/array/array.js";const FormOption=props=>{if(!isObjectStrict(props))return"";props=applyFilters("formOptionProps",props);const{args:args,parents:parents}=props,{label:label,value:value="",name:name,hint:hint,selected:selected,radioIcon:radioIcon,checkboxIcon:checkboxIcon,optionClasses:optionClasses,labelClasses:labelClasses,classes:classes}=isObjectStrict(args)?args:{};if(!isStringStrict(label))return"";if(!isArrayStrict(parents))return"";const fieldParent=parents[0];if(!isObjectStrict(fieldParent))return"";const{renderType:renderType,args:fieldArgs}=fieldParent;if("formField"!==renderType)return"";const{name:fieldName,type:fieldType}=fieldArgs,isRadioGroup="radio-group"===fieldType,isCheckboxGroup="checkbox-group"===fieldType,isSelect="select"===fieldType;if(!isRadioGroup&&!isCheckboxGroup&&!isSelect)return"";if(isSelect)return`<option value="${value}"${selected?" selected":""}>${label}</option>`;const inputName=name||fieldName;if(!isStringStrict(inputName))return"";const id=uuid();let optionIcon="";isRadioGroup&&isStringStrict(radioIcon)&&(optionIcon=radioIcon),isCheckboxGroup&&isStringStrict(checkboxIcon)&&(optionIcon=checkboxIcon);let hintOutput="";return isStringStrict(hint)&&(hintOutput=`<small data-form-hint>${hint}</small>`),`\n    <div${isStringStrict(optionClasses)?` class="${optionClasses}"`:""}>\n      <input\n        type="${isRadioGroup?"radio":"checkbox"}"\n        value="${value}"\n        name="${inputName}"\n        id="${id}"\n        ${isStringStrict(classes)?` class="${classes}"`:""}\n        data-form-input\n        ${selected?" checked":""}\n      >\n      <label for="${id}"${isStringStrict(labelClasses)?` class="${labelClasses}"`:""}>\n        <span data-form-option>\n          ${optionIcon}\n          <span data-form-label>\n            <span data-form-label-text>${label}</span>\n            ${hintOutput}\n          </span>\n        </span>\n      </label>\n    </div>\n  `};export{FormOption};

package/lib/objects/Form/FormTypes.d.ts

@@ -0,0 +1,76 @@
+import type { Generic, ParentArgs } from '../../global/globalTypes.js';
+import type { RenderFunctionArgs, RenderItem } from '../../render/renderTypes.js';
+export interface FormArgs extends Generic {
+    id?: string;
+    formTag?: string;
+    formClasses?: string;
+    formAttr?: string;
+    fields?: string;
+    fieldsClasses?: string;
+    fieldsAttr?: string;
+    submitFieldClasses?: string;
+    submitFieldAttr?: string;
+    submitLabel?: string;
+    submitClasses?: string;
+    submitAttr?: string;
+    honeypotName?: string;
+    honeypotFieldClasses?: string;
+    honeypotFieldAttr?: string;
+    honeypotLabelClasses?: string;
+    honeypotClasses?: string;
+    honeypotLabel?: string;
+    honeypotAttr?: string;
+}
+export interface FormProps<A = FormArgs, R = RenderItem> extends RenderFunctionArgs<A, R> {
+    args: FormArgs & A;
+}
+export interface FormMeta {
+    subject?: string;
+    toEmail?: string;
+    senderEmail?: string;
+}
+export type FormPropsFilter<A = FormArgs, R = RenderItem> = (props: FormProps<A, R>) => FormProps<A, R>;
+export type FormFieldType = 'text' | 'email' | 'checkbox' | 'radio' | 'number' | 'password' | 'tel' | 'url' | 'textarea' | 'select' | 'radio-group' | 'checkbox-group' | 'fieldset' | 'hidden' | 'file';
+export interface FormFieldArgs extends Generic {
+    type?: FormFieldType;
+    name?: string;
+    label?: string;
+    hint?: string;
+    value?: string;
+    required?: boolean;
+    attr?: string;
+    emptyError?: string;
+    invalidError?: string;
+    fieldsetClasses?: string;
+    fieldsetAttr?: string;
+    fieldTag?: string;
+    fieldClasses?: string;
+    fieldAttr?: string;
+    labelClasses?: string;
+    classes?: string;
+    radioIcon?: string;
+    checkboxIcon?: string;
+    selectIcon?: string;
+    requiredIcon?: string;
+}
+export interface FormFieldProps<A = FormFieldArgs, R = RenderItem> extends RenderFunctionArgs<A, R> {
+    args: FormFieldArgs & A;
+}
+export type FormFieldPropsFilter<A = FormFieldArgs, R = RenderItem> = (props: FormFieldProps<A, R>) => FormFieldProps<A, R>;
+export interface FormOptionArgs extends Generic {
+    label?: string;
+    value?: string;
+    name?: string;
+    hint?: string;
+    selected?: boolean;
+    optionClasses?: string;
+    labelClasses?: string;
+    classes?: string;
+    radioIcon?: string;
+    checkboxIcon?: string;
+}
+export interface FormOptionProps<A = FormOptionArgs, R = RenderItem, P = ParentArgs & FormFieldProps> extends RenderFunctionArgs<A, R, P> {
+    args: FormOptionArgs & A;
+    parents?: P[];
+}
+export type FormOptionPropsFilter<A = FormOptionArgs, R = RenderItem> = (props: FormOptionProps<A, R>) => FormOptionProps<A, R>;

package/lib/objects/Form/FormTypes.js

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

package/lib/package.json

@@ -0,0 +1 @@
+{"type": "module"}

package/lib/redirects/redirects.d.ts

@@ -0,0 +1,4 @@
+import type { RenderRedirect } from '../render/renderTypes.js';
+declare let redirects: string[];
+declare const setRedirects: (data?: RenderRedirect[]) => boolean;
+export { redirects, setRedirects };

package/lib/redirects/redirects.js

@@ -0,0 +1 @@
+import{isArrayStrict}from"../utils/array/array.js";import{isObjectStrict}from"../utils/object/object.js";let redirects=[];const setRedirects=data=>!!isArrayStrict(data)&&(redirects=[],data.forEach(item=>{if(!isObjectStrict(item))return;const{redirect:redirect}=item;isArrayStrict(redirect)&&(redirects=redirects.concat(redirect))}),redirects.length>1);export{redirects,setRedirects};

package/lib/redirects/redirectsFile.d.ts

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

package/lib/redirects/redirectsFile.js

@@ -0,0 +1 @@
+import{mkdir,writeFile}from"node:fs/promises";import{resolve,dirname}from"node:path";import{print}from"../utils/print/print.js";import{redirects}from"./redirects.js";const createRedirectsFile=async(path="site/_redirects")=>{const redirectsPath=resolve(path),redirectsDir=dirname(redirectsPath);await mkdir(redirectsDir,{recursive:!0}),await writeFile(redirectsPath,redirects.join("\n").trimEnd()),print("[FRM] Successfully wrote",redirectsPath,"success")};export{createRedirectsFile};

package/lib/render/render.d.ts

@@ -0,0 +1,11 @@
+import type { RenderContentArgs, RenderItemArgs, RenderItemReturn, RenderArgs, RenderReturn, RenderFunctions, RenderLayout, RenderHttpError, RenderNavigation, RenderFunctionsArgs } from './renderTypes.js';
+import type { RefString } from '../global/globalTypes.js';
+declare let renderFunctions: RenderFunctions;
+declare let renderLayout: RenderLayout;
+declare let renderHttpError: RenderHttpError;
+declare let renderNavigation: RenderNavigation;
+declare const setRenderFunctions: (args: RenderFunctionsArgs) => boolean;
+declare const renderContent: (args: RenderContentArgs, _html?: RefString) => Promise<string>;
+declare const renderItem: (args: RenderItemArgs, _contentType?: string) => Promise<RenderItemReturn | null>;
+declare const render: (args: RenderArgs) => Promise<RenderReturn[] | RenderReturn>;
+export { render, renderItem, renderContent, renderFunctions, renderLayout, renderNavigation, renderHttpError, setRenderFunctions };

package/lib/render/render.js

@@ -0,0 +1 @@
+import{doActions}from"../actions/actions.js";import{applyFilters}from"../filters/filters.js";import{getSlug,getPermalink}from"../utils/link/link.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{isFunction}from"../utils/function/function.js";import{doShortcodes}from"../shortcodes/shortcodes.js";import{tagExists}from"../utils/tag/tag.js";import{setStoreData,setStoreItem,getStoreItem}from"../store/store.js";import{setRedirects}from"../redirects/redirects.js";import{scripts,styles}from"../scripts/scripts.js";import{config}from"../config/config.js";let renderFunctions={},renderLayout=()=>"",renderHttpError=()=>"",renderNavigation=()=>{};const setRenderFunctions=args=>{if(!isObjectStrict(args))return!1;const{functions:functions,layout:layout,navigation:navigation,httpError:httpError}=args;return!(!isObjectStrict(functions)||!isFunction(layout))&&(renderFunctions={...functions},renderLayout=layout,isFunction(navigation)&&(renderNavigation=navigation),isFunction(httpError)&&(renderHttpError=httpError),!0)},getContentTemplate=(content,templates=[],named=!1)=>{if(!isArrayStrict(content))return{content:[],namedContent:{},templates:[]};const namedContent={},newContent=content.map(c=>(named&&isString(c.name)&&(namedContent[c.name]={...c}),tagExists(c,"template")?(templates.push({...c}),{metadata:{tags:[{id:"templateBreak"}]}}):c));return{namedContent:namedContent,content:newContent,templates:structuredClone(templates)}},mapContentTemplate=(templates,content=[],namedContent={},named=!1)=>{if(!isArrayStrict(templates))return templates;const lastTemplateIndex=templates.length-1;return templates.forEach((t,i)=>{content[0]&&tagExists(content[0],"templateBreak")&&content.length>=1&&content.shift();if(tagExists(t,"templateOptional")&&i===lastTemplateIndex&&!content.length)return void templates.pop();const isSlot=tagExists(t,"templateSlot");let children=t.content;if(isArrayStrict(children)&&!isSlot&&!named){let repeat;const newChildren=[...children],repeatIndex=children.findIndex(c=>{const isRepeat=tagExists(c,"templateRepeat");return isRepeat&&(repeat=c),isRepeat});if(-1!==repeatIndex&&repeat){let breakIndex=content.findIndex(c=>tagExists(c,"templateBreak"));breakIndex=-1===breakIndex?content.length:breakIndex;let insertIndex=repeatIndex;for(let j=insertIndex;j<breakIndex-1;j+=1)newChildren.splice(insertIndex,0,structuredClone(repeat)),insertIndex=j}children=newChildren}if(isSlot&&content.length>=1){let fill=null;return fill=named?namedContent[t.name]:content.shift(),void(fill&&(templates[i]=fill))}isArray(children)&&templates[i]&&(templates[i].content=mapContentTemplate(children,content,namedContent,named))}),templates},renderContent=async(args,_html={ref:""})=>{if(!isObjectStrict(args))return _html.ref;const{content:content=[],serverlessData:serverlessData,previewData:previewData,itemData:itemData,itemContains:itemContains=new Set,itemHeadings:itemHeadings=[],parents:parents=[],depth:depth=0}=args;let{headingsIndex:headingsIndex=-1}=args;if(!isArrayStrict(content))return _html.ref;for(const item of content){if(!isObjectStrict(item))continue;const props={...item},renderType=isString(props.renderType)?props.renderType:"",isRichText="richText"===renderType;let childrenArr,children=props.content;if("contentTemplate"===renderType){const isNamed=tagExists(item,"templateNamed"),template=getContentTemplate(isArray(props.content)?props.content:[],[],isNamed);children=mapContentTemplate(template.templates,template.content,template.namedContent,isNamed)}let childrenStr="";isArrayStrict(children)&&!isRichText&&(childrenArr=children),isStringStrict(children)&&!isRichText&&(childrenStr=children),"content"===renderType&&0===depth&&(headingsIndex=itemHeadings.push([])-1);let renderStart="",renderEnd="",filterType="",filterArgs={};const renderFunction=renderFunctions[renderType];if(isFunction(renderFunction)){childrenArr&&(props.content=void 0);const renderArgs={args:props,parents:parents,itemData:itemData,itemContains:itemContains,serverlessData:serverlessData,previewData:previewData};childrenArr&&(renderArgs.children=childrenArr),"richText"===renderType&&(renderArgs.headings=itemHeadings[headingsIndex]);const renderOutput=await renderFunction(renderArgs);if(isArrayStrict(renderOutput)){const[start,end]=renderOutput;isString(start)&&(renderStart=start),isString(end)&&(renderEnd=end)}isString(renderOutput)&&(renderStart=renderOutput,childrenArr=void 0),itemContains.add(renderType),filterType=renderType,filterArgs={...props,content:void 0}}const renderContentFilterArgs={renderType:filterType,args:filterArgs},[filterRenderStart,filterRenderEnd]=await applyFilters("renderContent",[renderStart,renderEnd],renderContentFilterArgs,!0);if(renderStart=filterRenderStart,renderEnd=filterRenderEnd,_html.ref+=renderStart+childrenStr,childrenArr){const parentsCopy=[...parents];renderType&&parentsCopy.unshift({renderType:renderType,args:{...props,content:void 0,parents:void 0}}),await renderContent({content:childrenArr,serverlessData:serverlessData,previewData:previewData,parents:parentsCopy,itemData:itemData,itemContains:itemContains,itemHeadings:itemHeadings,headingsIndex:headingsIndex,depth:depth+1},_html)}_html.ref+=renderEnd}return _html.ref},renderItem=async(args,_contentType)=>{if(!isObjectStrict(args))return null;const{item:item,serverlessData:serverlessData,previewData:previewData}=args;if(!isObjectStrict(item))return null;const contentType=item.contentType;if(!isStringStrict(contentType))return null;if("taxonomy"===contentType&&!0!==item.isPage)return null;const id=item.id;if(!isStringStrict(id))return null;if(!isStringStrict(item.slug))return null;let serverlessRender=!1;const itemContains=new Set,itemHeadings=[];scripts.deps.clear(),scripts.item.clear(),scripts.meta={},styles.deps.clear(),styles.item.clear();const renderItemStartArgs={id:id,itemData:{...item},contentType:contentType,itemContains:new Set,itemHeadings:[],serverlessData:serverlessData,previewData:previewData};await doActions("renderItemStart",renderItemStartArgs,!0);const title=item.title,meta={title:"",description:"",url:"",image:"",canonical:"",prev:"",next:"",index:!0,isIndex:!1,...item.meta};isStringStrict(item.metaTitle)&&(meta.title=item.metaTitle),isStringStrict(item.metaDescription)&&(meta.description=item.metaDescription),isStringStrict(item.metaImage?.url)&&(meta.image=item.metaImage.url),!isStringStrict(meta.title)&&isStringStrict(title)&&(meta.title=title);const slugArgs={id:id,contentType:contentType,slug:item.slug,returnParents:!0,itemData:item,page:0},s=getSlug(slugArgs,!0),slug=s.slug,slugIsHtml=slug.endsWith(".html"),permalink=getPermalink(slug,!slugIsHtml),parents=s.parents;meta.url=permalink,meta.canonical=permalink;const taxonomy="term"===contentType?item.taxonomy:"taxonomy"===contentType?item:null;item.baseUrl=permalink,item.baseType=isObjectStrict(taxonomy)&&isArrayStrict(taxonomy.contentTypes)?taxonomy.contentTypes:contentType;let formattedSlug="index"!==slug&&""!==slug?`/${slug}/`:"/";slugIsHtml&&(formattedSlug=slug);const index="index"===item.slug;let itemServerlessData;if(meta.isIndex=index,isObjectStrict(serverlessData)){if(!(serverlessData.path===formattedSlug&&null!=serverlessData.query))return{serverlessRender:!1};itemServerlessData=serverlessData}const itemData={...item};itemData.id=id,itemData.parents=parents,itemData.content=void 0;let contentOutput="";const contentData=item.content;isStringStrict(contentData)&&(contentOutput=contentData),isArrayStrict(contentData)&&(contentOutput=await renderContent({content:contentData,serverlessData:itemServerlessData,parents:[],itemData:itemData,itemContains:itemContains,itemHeadings:itemHeadings,previewData:previewData})),contentOutput=await doShortcodes(contentOutput,itemData);const pag=itemData.pagination;if(isObjectStrict(pag)){const{currentParams:currentParams,prevParams:prevParams,nextParams:nextParams}=pag,currentParamsStr=new URLSearchParams(currentParams).toString();if(currentParamsStr&&(meta.canonicalParams=`?${currentParamsStr}`),isStringStrict(pag.title)&&(meta.paginationTitle=pag.title),pag.prev){const prevSlugArgs={...slugArgs,params:prevParams},p=getSlug(prevSlugArgs,!0);meta.prev=getPermalink(p.slug,1===pag.prev&&!prevParams)}if(pag.next){const nextSlugArgs={...slugArgs,params:nextParams},n=getSlug(nextSlugArgs,!0);meta.next=getPermalink(n.slug,!1)}serverlessRender=!0}const cmsLocales=config.cms.locales,slugData=[id,isStringStrict(_contentType)?_contentType:contentType];if(isStringStrict(item.locale)&&cmsLocales){const locale=item.locale;cmsLocales.includes(locale)&&locale!==cmsLocales[0]&&slugData.push(locale)}(config.env.dev||config.env.prod&&serverlessRender)&&setStoreItem("slugs",slugData,slugIsHtml?`/${slug}`:formattedSlug);const layoutArgs={id:id,meta:meta,contentType:contentType,content:contentOutput,slug:formattedSlug,itemContains:itemContains,itemHeadings:itemHeadings,itemData:itemData,serverlessData:serverlessData,previewData:previewData};let layoutOutput=await renderLayout(layoutArgs);const renderItemFilterArgs={id:id,contentType:contentType,slug:formattedSlug,output:layoutOutput,itemData:itemData,itemContains:itemContains,itemHeadings:itemHeadings,serverlessData:serverlessData,previewData:previewData};layoutOutput=await applyFilters("renderItem",layoutOutput,renderItemFilterArgs,!0);const renderItemEndArgs={id:id,contentType:contentType,slug:formattedSlug,output:layoutOutput,itemData:itemData,itemContains:itemContains,itemHeadings:itemHeadings,serverlessData:serverlessData,previewData:previewData};return await doActions("renderItemEnd",renderItemEndArgs,!0),{serverlessRender:serverlessRender,itemData:itemData,data:{slug:formattedSlug,output:layoutOutput}}},render=async args=>{if(!isObjectStrict(args))return[];const{allData:allData,serverlessData:serverlessData,previewData:previewData}=args,isServerless=null!=serverlessData,isPreview=null!=previewData;if(scripts.deps.clear(),scripts.item.clear(),scripts.meta={},styles.deps.clear(),styles.item.clear(),!isObjectStrict(allData))return[];const{redirect:redirect,content:content}=allData;await doActions("renderStart",args,!0);const data=[];isServerless||setStoreData(allData),await renderNavigation({navigations:getStoreItem("navigations"),items:getStoreItem("navigationItems")}),setRedirects(redirect);for(const[contentType,contentItems]of Object.entries(content))if(isArrayStrict(contentItems))for(const contentItem of contentItems){const item=await renderItem({item:await applyFilters("renderItemData",contentItem,{contentType:contentType},!0),serverlessData:serverlessData,previewData:previewData},contentType);if(!item)continue;const{serverlessRender:serverlessRender=!1,data:itemData}=item;itemData&&(data.push(itemData),serverlessRender&&!isServerless&&setStoreItem("serverless",["reload"],itemData.slug))}const[outputItem]=data,output=(isServerless||isPreview)&&outputItem?outputItem:data;return await doActions("renderEnd",{...args,data:output},!0),output};export{render,renderItem,renderContent,renderFunctions,renderLayout,renderNavigation,renderHttpError,setRenderFunctions};

package/lib/render/renderInline.d.ts

@@ -0,0 +1,4 @@
+import type { RenderItem, RenderContentArgs, RenderInlineItem } from './renderTypes.js';
+declare const renderInlineContent: (content: RenderItem[], args?: Partial<Omit<RenderContentArgs, "content">>) => Promise<string>;
+declare const renderInlineItem: (item: RenderInlineItem) => Promise<string>;
+export { renderInlineContent, renderInlineItem };

package/lib/render/renderInline.js

@@ -0,0 +1 @@
+import{renderContent,renderItem}from"./render.js";import{isObjectStrict}from"../utils/object/object.js";import{isString}from"../utils/string/string.js";const renderInlineContent=async(content,args)=>await renderContent({content:content,parents:[],itemData:{},itemContains:new Set,itemHeadings:[],...args}),renderInlineItem=async item=>{if(!isObjectStrict(item))return"";const res=await renderItem({item:item});return isString(res?.data?.output)?res.data.output:""};export{renderInlineContent,renderInlineItem};

package/lib/render/renderTypes.d.ts

@@ -0,0 +1,197 @@
+import type { Generic, GenericStrings, InternalLink, Taxonomy, ParentArgs } from '../global/globalTypes.js';
+import type { NavigationList, NavigationItem, NavigationProps } from '../components/Navigation/NavigationTypes.js';
+import type { RichTextHeading } from '../text/RichText/RichTextTypes.js';
+import type { 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;
+    index?: boolean;
+    isIndex?: boolean;
+}
+export interface RenderBase {
+    itemData: RenderItem;
+    itemHeadings: RichTextHeading[][];
+    itemContains: Set<string>;
+    serverlessData?: RenderServerlessData;
+    previewData?: RenderPreviewData;
+}
+export interface RenderServerlessData {
+    path: string;
+    query?: Generic;
+}
+export interface RenderPreviewData {
+    id: string;
+    contentType: string;
+    locale?: string;
+}
+export interface RenderRedirect {
+    redirect: string[];
+}
+export interface RenderTag {
+    id: 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 type RenderNavigation = (args: NavigationProps) => void | Promise<void>;
+export interface RenderHttpErrorArgs extends Generic {
+    code: number;
+}
+export type RenderHttpError = (args: RenderHttpErrorArgs) => string | Promise<string>;
+export interface RenderFunctionArgs<A = any, R = RenderItem, P = ParentArgs, C = any> {
+    args: 0 extends (1 & A) ? any : A;
+    parents?: P[];
+    itemData?: R;
+    itemContains?: Set<string>;
+    serverlessData?: RenderServerlessData;
+    previewData?: RenderPreviewData;
+    headings?: RichTextHeading[];
+    children?: C[];
+}
+export type RenderFunction<A = any, R = RenderItem, P = ParentArgs, C = any> = (props: RenderFunctionArgs<A, R, P, C>) => string | string[] | Promise<string | string[]>;
+export type RenderFunctions<A = any, R = RenderItem, P = ParentArgs, C = any> = Record<string, RenderFunction<A, R, P, C>>;
+export interface RenderFunctionsArgs {
+    functions: RenderFunctions;
+    layout: RenderLayout;
+    navigation?: RenderNavigation;
+    httpError?: RenderHttpError;
+}
+export interface RenderContentArgs extends RenderBase {
+    content: RenderItem[];
+    parents: ParentArgs[];
+    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;
+    baseType?: string | string[];
+    archive?: string;
+    parent?: RenderItem;
+    taxonomy?: Taxonomy;
+    metadata?: RenderMetaTags;
+    pagination?: PaginationData;
+}
+export interface RenderItemArgs {
+    item: RenderItem;
+    serverlessData?: RenderServerlessData;
+    previewData?: RenderPreviewData;
+}
+interface RenderItemReturnData {
+    slug: string;
+    output: string;
+}
+export interface RenderItemReturn {
+    serverlessRender?: boolean;
+    itemData?: RenderItem;
+    data?: RenderItemReturnData;
+}
+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;
+    contentType: string;
+    content: string;
+    slug: string;
+    itemData: RenderItem;
+    itemHeadings?: RichTextHeading[][];
+    itemContains?: Set<string>;
+    serverlessData?: RenderServerlessData;
+    previewData?: RenderPreviewData;
+}
+export type RenderLayout = (args: RenderLayoutArgs) => string | Promise<string>;
+interface RenderAllDataContent {
+    page: RenderItem[];
+    [key: string]: RenderItem[];
+}
+export interface RenderAllData extends Generic {
+    navigation?: NavigationList[];
+    navigationItem?: NavigationItem[];
+    redirect?: RenderRedirect[];
+    content: RenderAllDataContent;
+}
+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;
+interface RenderItemDataFilterArgs {
+    contentType: string;
+}
+export type RenderItemDataFilter = (item: RenderItem, args: RenderItemDataFilterArgs) => 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 RenderData {
+    items: RenderItem[];
+    total?: number;
+    pages?: number;
+    skip?: number;
+    limit?: number;
+}
+export {};

package/lib/render/renderTypes.js

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

package/lib/scripts/scripts.d.ts

@@ -0,0 +1,8 @@
+import type { Scripts, Styles, ScriptsPriority } from './scriptsTypes.js';
+declare const scripts: Scripts;
+declare const styles: Styles;
+declare const addScript: (path: string, deps?: string[], priority?: ScriptsPriority) => boolean;
+declare const addStyle: (path: string, deps?: string[], priority?: ScriptsPriority) => boolean;
+declare const outputScripts: (link: string) => string;
+declare const outputStyles: (link: string) => string;
+export { scripts, styles, addScript, addStyle, outputScripts, outputStyles };

package/lib/scripts/scripts.js

@@ -0,0 +1 @@
+import{isArrayStrict}from"../utils/array/array.js";import{isStringStrict}from"../utils/string/string.js";import{config}from"../config/config.js";const scripts={priority:new Map,deps:new Map,item:new Map,build:new Map,meta:{}},styles={priority:new Map,deps:new Map,item:new Map,build:new Map},addScriptStyle=(type,path,deps=[],priority)=>{if(!isStringStrict(path))return!1;const isScripts="scripts"===type,assets=isScripts?scripts:styles,ext=isScripts?"js":"scss",{inputDir:inputDir,outputDir:outputDir}=config[type],input=`${inputDir}/${path}.${ext}`,output=`${outputDir}/${path}`;return assets.item.set(output,input),assets.build.set(output,input),isArrayStrict(deps)&&deps.forEach(dep=>{const depInput=`${inputDir}/${dep}.${ext}`,depOutput=`${outputDir}/${dep}`;assets.deps.has(output)||assets.deps.set(output,new Set),assets.deps.get(output)?.add(depOutput),assets.item.set(depOutput,depInput),assets.build.set(depOutput,depInput)}),priority&&assets.priority.set(output,priority),!0},addScript=(path,deps=[],priority)=>addScriptStyle("scripts",path,deps,priority),addStyle=(path,deps=[],priority)=>addScriptStyle("styles",path,deps,priority),outputScriptsStyles=(type,link)=>{if(!isStringStrict(link))return"";const{item:item,deps:deps,priority:priority}="scripts"===type?scripts:styles;if(!item.size)return"";const itemOut=Array.from(item.keys());itemOut.sort((a,b)=>{const aIsDep=deps.get(b)?.has(a),bIsDep=deps.get(a)?.has(b);return!0===aIsDep?-1:!0===bIsDep?1:0});let output="";return itemOut.forEach(out=>{const fetchPriority=priority.has(out)?` fetchpriority="${priority.get(out)}"`:"";"scripts"===type&&(output+=`<script type="module" src="${link}${out}.js"${fetchPriority}><\/script>`),"styles"===type&&(output+=`<link rel="stylesheet" href="${link}${out}.css" media="all"${fetchPriority}>`)}),output},outputScripts=link=>outputScriptsStyles("scripts",link),outputStyles=link=>outputScriptsStyles("styles",link);export{scripts,styles,addScript,addStyle,outputScripts,outputStyles};

package/lib/scripts/scriptsTypes.d.ts

@@ -0,0 +1,15 @@
+import type { Generic } from '../global/globalTypes.js';
+export type ScriptsPriority = 'high' | 'low';
+export interface Scripts {
+    item: Map<string, string>;
+    build: Map<string, string>;
+    deps: Map<string, Set<string>>;
+    priority: Map<string, ScriptsPriority>;
+    meta: Generic;
+}
+export interface Styles {
+    item: Map<string, string>;
+    build: Map<string, string>;
+    deps: Map<string, Set<string>>;
+    priority: Map<string, ScriptsPriority>;
+}

package/lib/scripts/scriptsTypes.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{getObjectKeys}from"../../utils/object/objectUtils.js";import{applyFilters}from"../../filters/filters.js";import{getPermalink}from"../../utils/link/link.js";import{getStoreItem}from"../../store/store.js";import{minify}from"../../utils/minify/minify.js";import{isFile}from"../../utils/file/file.js";const recurseEmailHtml=(data,html,plain,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&&(html.ref+='\n        <tr>\n          <td style="padding: 16px 0; border-bottom: 2px solid #ccc;">\n      '),label&&!isArr&&(html.ref+=`\n        <h${h} style="font-family: sans-serif; color: #222; margin: 16px 0; line-height: 1.3em">\n          ${l}\n        </h${h}>\n      `,plain.ref+=`${l}\n`),recurseEmailHtml(value,html,plain,depth+1),isString(value)&&(html.ref+=`\n        <p style="font-family: sans-serif; color: #222; margin: 16px 0; line-height: 1.5em;">\n          ${value}\n        </p>\n      `,plain.ref+=value.replace(/<br\s*\/?>/gi,"\n").replace(/(<([^>]+)>)/gi,"")+"\n"),1===depth&&(html.ref+="\n          </td>\n        </tr>\n      ",plain.ref+="\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={},html={ref:""},plain={ref:""};for(const[name,input]of Object.entries(inputs)){const inputType=input.type,inputLabel=input.label?.trim()||`[${name}]`,inputValue=input.value;let inputValueStr="";if(inputValueStr=isArray(inputValue)?inputValue.map(v=>isFile(v)?v.name:escape(v.toString().trim())).join("<br>"):isFile(inputValue)?inputValue.name:escape(inputValue.toString().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,html,plain);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                  ${html.ref}\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${plain.ref}${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/serverless.d.ts

@@ -0,0 +1,12 @@
+import type { ServerlessActions } from './serverlessTypes.js';
+import type { RenderPreviewData, RenderServerlessData } from '../render/renderTypes.js';
+import type { Generic, GenericStrings } from '../global/globalTypes.js';
+import type { getAllContentfulData } from '../contentful/contentfulData.js';
+import type { getAllWordPressData } from '../wordpress/wordpressData.js';
+declare let serverlessActions: ServerlessActions;
+declare const serverlessPreview: (request: Request) => RenderPreviewData | undefined;
+declare const serverlessReload: (request: Request, allowedParams?: string[]) => RenderServerlessData | undefined;
+declare const serverlessRender: (getData: typeof getAllContentfulData | typeof getAllWordPressData, serverlessData?: RenderServerlessData, previewData?: RenderPreviewData) => Promise<Response>;
+declare const setServerless: (actions?: ServerlessActions) => void;
+declare const doServerlessAction: (request: Request, env: Generic, headers?: GenericStrings, honeypotName?: string) => Promise<Response>;
+export { serverlessActions, serverlessPreview, serverlessReload, serverlessRender, setServerless, doServerlessAction };

package/lib/serverless/serverless.js

@@ -0,0 +1 @@
+import{ResponseError}from"../utils/ResponseError/ResponseError.js";import{isStringStrict}from"../utils/string/string.js";import{isObjectStrict}from"../utils/object/object.js";import{isFunction}from"../utils/function/function.js";import{applyFilters}from"../filters/filters.js";import{render,renderHttpError}from"../render/render.js";import{minify}from"../utils/minify/minify.js";import{print}from"../utils/print/print.js";let serverlessActions={};const serverlessPreview=request=>{const{method:method,url:url}=request;if("GET"!==method)return;const{searchParams:searchParams}=new URL(url),contentType=searchParams.get("content_type"),locale=searchParams.get("locale"),id=searchParams.get("preview");if(!isStringStrict(id)||!isStringStrict(contentType))return;const previewData={id:id,contentType:contentType};return isStringStrict(locale)&&(previewData.locale=locale),previewData},serverlessReload=(request,allowedParams=["page","filters"])=>{const{method:method,url:url}=request;if("GET"!==method)return;const{searchParams:searchParams,pathname:pathname}=new URL(url),path=pathname,query={};let hasParams=!1;for(const param of allowedParams){const value=searchParams.get(param);isStringStrict(value)&&(query[param]=value,hasParams=!0)}return hasParams?{query:query,path:path}:void 0},serverlessRender=async(getData,serverlessData,previewData)=>{try{const data=await render({serverlessData:serverlessData,previewData:previewData,allData:await getData({serverlessData:serverlessData,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"}})}catch(error){print("[FRM] Error on serverless render",error);const status=500,html=await renderHttpError({code:status});return new Response(html,{status:status,headers:{"Content-Type":"text/html;charset=UTF-8"}})}},setServerless=actions=>{isObjectStrict(actions)&&(serverlessActions={...actions})},doServerlessAction=async(request,env,headers,honeypotName)=>{const serverlessHeaders={"Content-Type":"application/json",...headers};try{if("POST"!==request.method)return new Response(JSON.stringify({error:"Method not allowed"}),{status:405,headers:serverlessHeaders});const data=await request.json();if(!isObjectStrict(data))throw new Error("Data not an object");if(isStringStrict(honeypotName)&&isObjectStrict(data.inputs?.[honeypotName])){const honeypotValue=data.inputs[honeypotName].value;if(isStringStrict(honeypotValue))return new Response(JSON.stringify({success:""}),{status:200,headers:serverlessHeaders});delete data.inputs[honeypotName]}const action=data.action;if(!isStringStrict(action))throw new Error("No action");let res=null;const serverlessAction=serverlessActions[action];isFunction(serverlessAction)&&(res=await serverlessAction(data,request,env));const serverlessResultFilterArgs={data:data,request:request,env:env};if(res=await applyFilters("serverlessResult",res,serverlessResultFilterArgs,!0),!res)throw new Error("No result");if(res.error){const errorMessage=res.error.message;throw res.error.response?new ResponseError(errorMessage,res.error.response):new Error(errorMessage)}const options={status:200,headers:serverlessHeaders};let message="";if(res.success){const{message:successMessage,headers:successHeaders}=res.success;isStringStrict(successMessage)&&(message=successMessage),isObjectStrict(successHeaders)&&(options.headers={...options.headers,...successHeaders})}return new Response(JSON.stringify({success:message}),options)}catch(error){print("[FRM] Error with serverless action",error);let statusCode=500,message=error instanceof Error?error.message:"Unknown error";return error instanceof ResponseError&&(statusCode=error.response.status,message=error.message),new Response(JSON.stringify({error:message}),{status:statusCode,headers:serverlessHeaders})}};export{serverlessActions,serverlessPreview,serverlessReload,serverlessRender,setServerless,doServerlessAction};

package/lib/serverless/serverlessTypes.d.ts

@@ -0,0 +1,41 @@
+import type { Generic, GenericStrings } from '../global/globalTypes.js';
+export interface ServerlessRoute {
+    path: string;
+    content?: string;
+}
+export type ServerlessActionPrimitive = string | number | boolean | File;
+export interface ServerlessActionInput extends Generic {
+    value: ServerlessActionPrimitive | ServerlessActionPrimitive[];
+    type: string | string[];
+    label?: string;
+    legend?: string;
+}
+export interface ServerlessActionData {
+    id: string;
+    action: string;
+    inputs: Record<string, ServerlessActionInput>;
+}
+export interface ServerlessActionError {
+    message: string;
+    response?: Response;
+}
+export interface ServerlessActionSuccess {
+    message: string;
+    headers?: GenericStrings;
+}
+export interface ServerlessActionReturn {
+    error?: ServerlessActionError;
+    success?: ServerlessActionSuccess;
+}
+export type ServerlessAction = (args: ServerlessActionData, request: Request, env: Generic) => Promise<ServerlessActionReturn> | ServerlessActionReturn;
+export type ServerlessActions = Record<string, ServerlessAction>;
+export interface ServerlessResultOptions {
+    status: number;
+    headers?: GenericStrings;
+}
+export interface ServerlessResultFilterArgs {
+    data: ServerlessActionData;
+    request: Request;
+    env: Generic;
+}
+export type ServerlessResultFilter = (res: ServerlessActionReturn | null, args: ServerlessResultFilterArgs) => Promise<ServerlessActionReturn | null>;

package/lib/serverless/serverlessTypes.js

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

package/lib/shortcodes/shortcodes.d.ts

@@ -0,0 +1,10 @@
+import type { Shortcode, Shortcodes, ShortcodesSet } from './shortcodesTypes.js';
+import type { RenderItem } from '../render/renderTypes.js';
+declare const shortcodes: Shortcodes;
+declare const addShortcode: <T extends Shortcode>(name: string, shortcode: T) => boolean;
+declare const removeShortcode: (name: string) => boolean;
+declare const doShortcodes: (content: string, itemData?: RenderItem) => Promise<string>;
+declare const resetShortcodes: () => void;
+declare const setShortcodes: <T extends ShortcodesSet>(args: T) => boolean;
+declare const stripShortcodes: (content: string) => string;
+export { shortcodes, addShortcode, removeShortcode, doShortcodes, resetShortcodes, setShortcodes, stripShortcodes };

package/lib/shortcodes/shortcodes.js

@@ -0,0 +1 @@
+import{isObjectStrict}from"../utils/object/object.js";import{isArrayStrict}from"../utils/array/array.js";import{isStringStrict}from"../utils/string/string.js";import{isFunction}from"../utils/function/function.js";import{escape}from"../utils/escape/escape.js";const shortcodes=new Map,attrReg=/[\w-]+=".*?"/g,getShortcodeData=(content,tagNames,props,itemData)=>{if(!isStringStrict(content)||!isStringStrict(tagNames))return[];const reg=new RegExp(String.raw`\[(?:\/)?(?<name>${tagNames})(?:\s[^\]]*?)?\]`,"g"),matches=[...content.matchAll(reg)];if(!matches.length)return[];const data=[];return matches.forEach((opening,i)=>{const name=opening.groups?.name,tag=opening[0];if(!isStringStrict(name)||tag.startsWith("[/"))return;const info=props||shortcodes.get(name);if(!isObjectStrict(info))return;const child=info.child,hasChild=isStringStrict(child),startIndex=opening.index,startLen=tag.length;let endIndex=startIndex+tag.length,endLen=0;const closingTag=`[/${name}]`,closingMatch=hasChild?matches.find(m=>m[0]===closingTag):matches[i+1];closingMatch?.[0]===closingTag&&(endIndex=closingMatch.index,endLen=closingTag.length);const attrs={},attrTypes=isObjectStrict(info.attrTypes)?info.attrTypes:{},attr=tag.match(attrReg);isArrayStrict(attr)&&attr.forEach(a=>{const[key,value]=a.split("="),type=attrTypes[key];let val=escape(value.replace(/"/g,""));if("number"===type){const num=parseInt(val,10);val=isNaN(num)?0:num}"boolean"===type&&(val="true"===val),attrs[key]=val});const replaceContent=content.slice(startIndex,endIndex+endLen),innerContent=content.slice(startIndex+startLen,endIndex);let children=[];hasChild&&(children=getShortcodeData(innerContent,child,props,itemData)),data.push({name:name,replaceContent:replaceContent,content:innerContent,attr:attrs,children:children,itemData:itemData})}),data},addShortcode=(name,shortcode)=>!(!isStringStrict(name)||!isObjectStrict(shortcode))&&(shortcodes.set(name,shortcode),!0),removeShortcode=name=>!!isStringStrict(name)&&shortcodes.delete(name),doShortcodes=async(content,itemData)=>{if(!shortcodes.size)return content;const names=[...shortcodes.keys()].join("|"),data=getShortcodeData(content,names,void 0,itemData);if(!data.length)return content;let newContent=content;for(const datum of data){const{name:name,replaceContent:replaceContent}=datum,callback=shortcodes.get(name)?.callback;isFunction(callback)&&(newContent=newContent.replace(replaceContent,await callback({...datum,itemData:itemData})))}return newContent},resetShortcodes=()=>{shortcodes.clear()},setShortcodes=args=>{if(!isObjectStrict(args))return!1;const names=Object.entries(args);return!!names.length&&(resetShortcodes(),names.forEach(([name,shortcode])=>{addShortcode(name,shortcode)}),!0)},stripShortcodes=content=>{if(!shortcodes.size)return content;const names=[...shortcodes.keys()].join("|"),reg=new RegExp(String.raw`\[(?:\/)?(?<name>${names})(?:\s[^\]]*?)?\]`,"g");return content.replace(reg,()=>"")};export{shortcodes,addShortcode,removeShortcode,doShortcodes,resetShortcodes,setShortcodes,stripShortcodes};

package/lib/shortcodes/shortcodesTypes.d.ts

@@ -0,0 +1,20 @@
+import type { RenderItem } from '../render/renderTypes.js';
+export type ShortcodeAttrValue = string | number | boolean | undefined;
+export type ShortcodeAttrs = Record<string, ShortcodeAttrValue>;
+export type ShortcodeAttrTypes = Record<string, 'string' | 'number' | 'boolean'>;
+export interface ShortcodeData {
+    name: string;
+    replaceContent: string;
+    content: string;
+    attr: ShortcodeAttrs;
+    children: ShortcodeData[];
+    itemData?: RenderItem;
+}
+export type ShortcodeCallback = (args: ShortcodeData) => string | Promise<string>;
+export interface Shortcode {
+    callback: ShortcodeCallback;
+    attrTypes?: ShortcodeAttrTypes;
+    child?: string;
+}
+export type Shortcodes = Map<string, Shortcode>;
+export type ShortcodesSet = Record<string, Shortcode>;

package/lib/shortcodes/shortcodesTypes.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{getArchiveMeta}from"../utils/archive/archive.js";import{config}from"../config/config.js";let storeDir="lib/store";const defaultStore={slugs:{},parents:{},navigations:[],navigationItems:[],formMeta:{},archiveMeta:{},imageMeta:{},taxonomies:{},serverless:{}};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,locale:locale}=item;if(!isStringStrict(id))return;const archiveType=normalizeContentType(archive);if(isStringStrict(archiveType)){const hasLocale=isStringStrict(locale),archiveMeta=getArchiveMeta(archiveType),newArchive={id:id,slug:slug,title:title,contentType:type,...hasLocale?archiveMeta[locale]:archiveMeta};hasLocale?(store.archiveMeta[archiveType]||(store.archiveMeta[archiveType]={}),store.archiveMeta[archiveType][locale]=newArchive):store.archiveMeta[archiveType]=newArchive}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]=[parentId,parentSlug,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,28 @@
+import type { Generic, Taxonomy } from '../global/globalTypes.js';
+import type { NavigationList, NavigationItem } from '../components/Navigation/NavigationTypes.js';
+import type { ArchiveMeta } from '../utils/archive/archiveTypes.js';
+import type { ImageProps } from '../utils/image/imageTypes.js';
+import type { FormMeta } from '../objects/Form/FormTypes.js';
+export type StoreSlugs = Record<string, [string, string, string?]>;
+export type StoreParents = Record<string, Record<string, [string, string, string]>>;
+export type StoreArchiveMeta = Record<string, ArchiveMeta | Record<string, ArchiveMeta>>;
+export type StoreFormMeta = Record<string, FormMeta>;
+export type StoreImageMeta = Record<string, ImageProps>;
+export type StoreTaxonomies = Record<string, Taxonomy>;
+interface StorePrimitiveGeneric {
+    [key: string]: StorePrimitive;
+}
+export type StorePrimitive = string | number | boolean | null | undefined | StorePrimitive[] | StorePrimitiveGeneric;
+export type StoreServerless<T extends StorePrimitive[]> = Record<string, T>;
+export interface Store extends Generic {
+    slugs: StoreSlugs;
+    parents: StoreParents;
+    archiveMeta: StoreArchiveMeta;
+    formMeta: StoreFormMeta;
+    imageMeta: StoreImageMeta;
+    navigations: NavigationList[];
+    navigationItems: NavigationItem[];
+    taxonomies: StoreTaxonomies;
+    serverless: StoreServerless<StorePrimitive[]>;
+}
+export {};

package/lib/store/storeTypes.js

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