@alanizcreative/formation-static 0.0.1

package/lib/components/Navigation/NavigationTypes.d.ts

@@ -0,0 +1,88 @@
+import type { InternalLink, Generic, RefString } from '../../global/globalTypes.js';
+export interface NavigationProps {
+    navigations: NavigationList[];
+    items: NavigationItem[];
+    currentLink?: string;
+    currentType?: string | string[];
+}
+export interface NavigationList extends Generic {
+    title: string;
+    location: string | string[];
+    items: NavigationItem[];
+}
+export interface NavigationByLocationItem {
+    title: string;
+    items: NavigationItem[];
+}
+export type NavigationByLocation<L extends string = string> = Map<L, NavigationByLocationItem>;
+export interface NavigationItem extends Generic {
+    id: string;
+    title: string;
+    link?: string;
+    internalLink?: InternalLink;
+    externalLink?: string;
+    children?: NavigationItem[];
+    current?: boolean;
+    external?: boolean;
+    descendentCurrent?: boolean;
+    archiveCurrent?: boolean;
+}
+export type NavigationItemsById = Map<string, NavigationItem>;
+export interface NavigationBreadcrumbItem extends NavigationItem {
+    slug: string;
+    contentType: string;
+}
+export interface NavigationOutputBaseArgs {
+    listClass?: string;
+    listAttr?: string;
+    itemClass?: string;
+    itemAttr?: string;
+    linkClass?: string;
+    internalLinkClass?: string;
+    linkAttr?: string;
+    depthAttr?: boolean;
+    dataAttr?: string;
+}
+export interface NavigationOutputListFilterArgs {
+    args: NavigationOutputArgs;
+    output: RefString;
+    items: NavigationItem[];
+    depth: number;
+}
+export interface NavigationOutputFilterArgs {
+    args: NavigationOutputArgs;
+    item: NavigationItem;
+    output: RefString;
+    index: number;
+    items: NavigationItem[];
+    depth: number;
+}
+export type NavigationOutputListFilter = (args: NavigationOutputListFilterArgs) => void;
+export type NavigationFilter = (args: NavigationOutputFilterArgs) => void;
+export interface NavigationOutputArgs extends NavigationOutputBaseArgs {
+    currentLink?: string;
+    currentType?: string | string[];
+    listTag?: string;
+    itemTag?: string;
+    filterBeforeList?: NavigationOutputListFilter;
+    filterAfterList?: NavigationOutputListFilter;
+    filterBeforeItem?: NavigationFilter;
+    filterAfterItem?: NavigationFilter;
+    filterBeforeLink?: NavigationFilter;
+    filterAfterLink?: NavigationFilter;
+    filterBeforeLinkText?: NavigationFilter;
+    filterAfterLinkText?: NavigationFilter;
+}
+export interface NavigationBreadcrumbOutputFilterArgs {
+    output: RefString;
+    lastLevel: boolean;
+}
+export type NavigationBreadcrumbOutputFilter = (args: NavigationBreadcrumbOutputFilterArgs) => void;
+export interface NavigationBreadcrumbOutputArgs extends NavigationOutputBaseArgs {
+    current?: string;
+    currentClass?: string;
+    currentLabel?: string;
+    a11yClass?: string;
+    filterBeforeLink?: NavigationBreadcrumbOutputFilter;
+    filterAfterLink?: NavigationBreadcrumbOutputFilter;
+}

package/lib/components/Navigation/NavigationTypes.js

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

package/lib/components/Pagination/Pagination.d.ts

@@ -0,0 +1,3 @@
+import type { PaginationProps, PaginationReturn } from './PaginationTypes.js';
+declare const Pagination: (props: PaginationProps) => PaginationReturn;
+export { Pagination };

package/lib/components/Pagination/Pagination.js

@@ -0,0 +1 @@
+import{isObjectStrict}from"../../utils/object/object.js";import{isStringStrict}from"../../utils/string/string.js";const Pagination=props=>{const fallback={output:"",data:{}};if(!isObjectStrict(props))return fallback;const{total:total=1,display:display=5,current:current=1,filters:filters,url:url,ellipsis:ellipsis,first:first,last:last,prev:prev="",next:next="",firstLabel:firstLabel="First page",lastLabel:lastLabel="Last page",prevLabel:prevLabel="Previous page",nextLabel:nextLabel="Next page",currentLabel:currentLabel="Current page",pageLabel:pageLabel="Page",titleTemplate:titleTemplate="Page %current of %total",args:args}=props,{listClass:listClass,listAttr:listAttr,itemClass:itemClass,itemAttr:itemAttr,linkClass:linkClass,linkAttr:linkAttr,currentClass:currentClass,a11yClass:a11yClass="a-hide-vis",firstClass:firstClass,lastClass:lastClass,prevSpanClass:prevSpanClass,prevLinkClass:prevLinkClass,nextSpanClass:nextSpanClass,nextLinkClass:nextLinkClass}=isObjectStrict(args)?args:{};if(total<=1||!isStringStrict(url))return fallback;let output="";const hasFilters=isObjectStrict(filters);let firstParams={},lastParams={page:total.toString()},prevParams={},nextParams={},currentParams={};const prevPage=current-1,nextPage=current+1<=total?current+1:0;current>1&&(currentParams.page=current.toString()),prevPage>1&&(prevParams.page=prevPage.toString()),nextPage&&(nextParams.page=nextPage.toString()),hasFilters&&(firstParams={...firstParams,...filters},lastParams={...lastParams,...filters},currentParams={...currentParams,...filters},prevParams={...prevParams,...filters},current<total&&(nextParams={...nextParams,...filters}));const lastParamsStr=`?${new URLSearchParams(lastParams).toString()}`;let firstParamsStr=new URLSearchParams(firstParams).toString(),prevParamsStr=new URLSearchParams(prevParams).toString(),nextParamsStr=new URLSearchParams(nextParams).toString(),currentParamsStr=new URLSearchParams(currentParams).toString();firstParamsStr&&(firstParamsStr=`?${firstParamsStr}`),prevParamsStr&&(prevParamsStr=`?${prevParamsStr}`),nextParamsStr&&(nextParamsStr=`?${nextParamsStr}`),currentParamsStr&&(currentParamsStr=`?${currentParamsStr}`);const data={current:current,total:total};nextPage&&(data.next=nextPage),prevPage&&(data.prev=prevPage),currentParamsStr&&(data.currentParams=currentParams),nextParamsStr&&(data.nextParams=nextParams),prevParamsStr&&(data.prevParams=prevParams),firstParamsStr&&(data.firstParams=firstParams),data.lastParams=lastParams,current>1&&(data.title=titleTemplate.replace("%current",current.toString()).replace("%total",total.toString()));const max=display-1,half=Math.ceil(display/2),maxHalf=max/2,center=total>max,limit=center?max:total-1;let start=1;center&&(start=current<max?1:current-maxHalf),start>total-limit&&(start=total-limit);const totalPagesItems=start+limit,listAttrs=[];isStringStrict(listClass)&&listAttrs.push(`class="${listClass}"`),isStringStrict(listAttr)&&listAttrs.push(listAttr);const hasEllipsis=isStringStrict(ellipsis),itemAttrs=`${isStringStrict(itemClass)?` class="${itemClass}"`:""}${isStringStrict(itemAttr)?` ${itemAttr}`:""}`;isStringStrict(first)&&(output+=`\n      <li${itemAttrs} data-pag-first>\n        <a\n          href="${url}${firstParamsStr}"\n          aria-label="${firstLabel}"${isStringStrict(firstClass)?` class="${firstClass}"`:""}\n        >\n          ${first}\n        </a>\n      </li>\n    `);let prevItem=`<span${isStringStrict(prevSpanClass)?` class="${prevSpanClass}"`:""}>${prev}</span>`,isPrevLink=!1;current>1&&(isPrevLink=!0,prevItem=`\n      <a\n        href="${url}${prevParamsStr}"\n        aria-label="${prevLabel}"${isStringStrict(prevLinkClass)?` class="${prevLinkClass}"`:""}\n      >\n        ${prev}\n      </a>\n    `),output+=`<li${itemAttrs} data-pag-prev="${isPrevLink?"link":"text"}">${prevItem}</li>`;let ellipsisOutput="";hasEllipsis&&(ellipsisOutput=`<li${itemAttrs} aria-hidden="true" data-pag-ellipsis>${ellipsis}</li>`),center&&current>=limit&&current>half&&(output+=ellipsisOutput);for(let i=start;i<=totalPagesItems;i+=1){const isCurrent=i===current;let content="";if(isCurrent)content=`\n        <span${isStringStrict(currentClass)?` class="${currentClass}"`:""}>\n          <span class="${a11yClass}">${currentLabel} </span>\n          ${i}\n        </span>\n      `;else{let params={};i>1&&(params.page=i.toString()),hasFilters&&(params={...params,...filters});let paramsStr=new URLSearchParams(params).toString();paramsStr&&(paramsStr=`?${paramsStr}`),content=`\n        <a href="${url}${paramsStr}"${isStringStrict(linkClass)?` class="${linkClass}"`:""}${isStringStrict(linkAttr)?` ${linkAttr}`:""}>\n          <span class="${a11yClass}">${pageLabel} </span>\n          ${i}\n        </a>\n      `}output+=`<li${itemAttrs}${isCurrent?" data-pag-current":""}>${content}</li>`}center&&current<total-maxHalf&&(output+=ellipsisOutput);let nextItem=`<span${isStringStrict(nextSpanClass)?` class="${nextSpanClass}"`:""}>${next}</span>`,nextLink=!1;return current<total&&(nextLink=!0,nextItem=`\n      <a\n        href="${url}${nextParamsStr}"\n        aria-label="${nextLabel}"${isStringStrict(nextLinkClass)?` class="${nextLinkClass}"`:""}\n      >\n        ${next}\n      </a>\n    `),output+=`<li${itemAttrs} data-pag-next="${nextLink?"link":"text"}">${nextItem}</li>`,isStringStrict(last)&&(output+=`\n      <li${itemAttrs} data-pag-last>\n        <a\n          href="${url}${lastParamsStr}"\n          aria-label="${lastLabel}"${isStringStrict(lastClass)?` class="${lastClass}"`:""}\n        >\n          ${last}\n        </a>\n      </li>\n    `),{output:`\n      <ol${listAttrs.length?` ${listAttrs.join(" ")}`:""}>\n        ${output}\n      </ol>\n    `,data:data}};export{Pagination};

package/lib/components/Pagination/PaginationTypes.d.ts

@@ -0,0 +1,54 @@
+export interface PaginationProps {
+    total?: number;
+    display?: number;
+    current?: number;
+    filters?: Record<string, string>;
+    url?: string;
+    ellipsis?: string;
+    first?: string;
+    last?: string;
+    prev?: string;
+    next?: string;
+    firstLabel?: string;
+    lastLabel?: string;
+    prevLabel?: string;
+    nextLabel?: string;
+    currentLabel?: string;
+    pageLabel?: string;
+    titleTemplate?: string;
+    args?: PaginationArgs;
+}
+export interface PaginationArgs {
+    listClass?: string;
+    listAttr?: string;
+    itemClass?: string;
+    itemAttr?: string;
+    linkClass?: string;
+    linkAttr?: string;
+    currentClass?: string;
+    a11yClass?: string;
+    firstClass?: string;
+    lastClass?: string;
+    prevSpanClass?: string;
+    prevLinkClass?: string;
+    nextSpanClass?: string;
+    nextLinkClass?: string;
+}
+export interface PaginationData {
+    current?: number;
+    total?: number;
+    title?: string;
+    first?: number;
+    last?: number;
+    next?: number;
+    prev?: number;
+    firstParams?: Record<string, string>;
+    lastParams?: Record<string, string>;
+    nextParams?: Record<string, string>;
+    prevParams?: Record<string, string>;
+    currentParams?: Record<string, string>;
+}
+export interface PaginationReturn {
+    output: string;
+    data: PaginationData;
+}

package/lib/components/Pagination/PaginationTypes.js

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

package/lib/config/config.d.ts

@@ -0,0 +1,5 @@
+import type { Config, ConfigSet, ConfigSetFilter } from './configTypes.js';
+declare let config: Config;
+declare const setConfig: ConfigSet;
+declare const setConfigFilter: ConfigSetFilter;
+export { config, setConfig, setConfigFilter };

package/lib/config/config.js

@@ -0,0 +1 @@
+let config={namespace:"frm",source:"cms",title:"",meta:{description:"",image:""},partialTypes:[],wholeTypes:[],hierarchicalTypes:[],localeInSlug:{},typeInSlug:{},taxonomyInSlug:{},normalTypes:{},renderTypes:{},env:{dev:!0,prod:!1,build:!1,cache:!1,dir:"",devUrl:"",prodUrl:""},cms:{name:"",space:"",prodUser:"",prodCredential:"",prodHost:"",devUser:"",devCredential:"",devHost:""},local:{dir:"json"},scripts:{inputDir:"lib",outputDir:"js"},styles:{inputDir:"src",outputDir:"css"},image:{inputDir:"src/assets/img",outputDir:"site/assets/img",localUrl:"/assets/img",remoteUrl:"",quality:75,sizes:[200,400,600,800,1e3,1200,1600,2e3]},filter:config=>config};const setConfig=args=>(config={...config,...args},config),setConfigFilter=env=>(config=config.filter(config,env),config);export{config,setConfig,setConfigFilter};

package/lib/config/configTypes.d.ts

@@ -0,0 +1,66 @@
+import type { Source, GenericStrings, Generic } from '../global/globalTypes.js';
+export interface ConfigMeta {
+    description: string;
+    image: string;
+}
+export interface ConfigEnv {
+    dev: boolean;
+    prod: boolean;
+    build: boolean;
+    cache: boolean;
+    dir: string;
+    devUrl: string;
+    prodUrl: string;
+}
+export interface ConfigCms {
+    name: string;
+    space: string;
+    prodUser: string;
+    prodCredential: string;
+    prodHost: string;
+    devUser: string;
+    devCredential: string;
+    devHost: string;
+    ssl?: boolean;
+    env?: string;
+    locales?: string[];
+}
+export interface ConfigLocal {
+    dir: string;
+}
+export interface ConfigAsset {
+    inputDir: string;
+    outputDir: string;
+}
+export interface ConfigImage {
+    inputDir: string;
+    outputDir: string;
+    localUrl: string;
+    remoteUrl: string;
+    sizes: number[];
+    quality: number;
+}
+export type ConfigFilter = (config: Config, env: Generic) => Config;
+export interface Config {
+    namespace: string;
+    source: Source;
+    title: string;
+    meta: ConfigMeta;
+    partialTypes: string[];
+    wholeTypes: string[];
+    renderTypes: GenericStrings;
+    normalTypes: GenericStrings;
+    hierarchicalTypes: string[];
+    localeInSlug: Record<string, string>;
+    typeInSlug: Record<string, string | Record<string, string>>;
+    taxonomyInSlug: Record<string, string | Record<string, string>>;
+    env: ConfigEnv;
+    cms: ConfigCms;
+    local: ConfigLocal;
+    scripts: ConfigAsset;
+    styles: ConfigAsset;
+    image: ConfigImage;
+    filter: ConfigFilter;
+}
+export type ConfigSet = (args: Partial<Config>) => Config;
+export type ConfigSetFilter = (env: Generic) => Config;

package/lib/config/configTypes.js

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

package/lib/contentful/contentfulData.d.ts

@@ -0,0 +1,5 @@
+import type { ContentfulDataParams, AllContentfulDataArgs } from './contentfulDataTypes.js';
+import type { RenderAllData, RenderData } from '../render/renderTypes.js';
+declare const getContentfulData: (key: string, params?: ContentfulDataParams) => Promise<RenderData>;
+declare const getAllContentfulData: (args?: AllContentfulDataArgs) => Promise<RenderAllData | undefined>;
+export { getContentfulData, getAllContentfulData };

package/lib/contentful/contentfulData.js

@@ -0,0 +1 @@
+import resolveResponse from"contentful-resolve-response";import{applyFilters}from"../filters/filters.js";import{isObject,isObjectStrict}from"../utils/object/object.js";import{isStringStrict}from"../utils/string/string.js";import{config}from"../config/config.js";import{getStoreItem}from"../store/store.js";import{normalizeContentfulData}from"./contentfulDataNormal.js";const getContentfulData=async(key,params)=>{if(!isStringStrict(key))throw new Error("No key");if(config.env.cache){const cacheDataFilterArgs={key:key,type:"get"},cacheData=await applyFilters("cacheData",void 0,cacheDataFilterArgs,!0);if(isObject(cacheData))return structuredClone(cacheData)}const{space:space,devCredential:devCredential,prodCredential:prodCredential,devHost:devHost,prodHost:prodHost,env:env="master"}=config.cms;let accessToken=devCredential,host=devHost;if(config.env.prod&&(accessToken=prodCredential,host=prodHost),!isStringStrict(space)||!isStringStrict(accessToken)||!isStringStrict(host))throw new Error("No credentials");let url=`https://${host}/spaces/${space}/environments/${env}/entries?access_token=${accessToken}`;if(isObjectStrict(params))for(const[key,value]of Object.entries(params))url+=`&${key}=${value.toString()}`;const resp=await fetch(url),data=await resp.json();if(!resp.ok){const message=isStringStrict(data.message)?data.message:"Bad fetch response";throw new Error(message,{cause:data})}const resolvedData=resolveResponse(data),newItems=normalizeContentfulData(resolvedData),{total:total,limit:limit,skip:skip}=data,newData={items:newItems,total:total,limit:limit,skip:skip};if(config.env.cache){const cacheDataFilterArgs={key:key,type:"set",data:data};await applyFilters("cacheData",newData,cacheDataFilterArgs,!0)}return newData},getAllContentfulData=async args=>{const{serverlessData:serverlessData,previewData:previewData}=isObjectStrict(args)?args:{};let allData={navigationItem:[],navigation:[],content:{page:[]}};const isServerless=null!=serverlessData,isPreview=null!=previewData,contentfulDataFilterArgs={serverlessData:serverlessData,previewData:previewData},cmsLocales=config.cms.locales||[],defaultLocale=cmsLocales[0],paramLocales=isPreview?[]:[...cmsLocales];if(0===paramLocales.length&&paramLocales.push(""),isServerless||isPreview){let locale,contentType="",id="";if(isServerless){const item=getStoreItem("slugs")[serverlessData.path];if(item){const[itemId,itemContentType,itemLocale]=item;id=itemId||"",contentType=itemContentType||"",locale=itemLocale||""}}if(isPreview&&(id=previewData.id,contentType=previewData.contentType,locale=previewData.locale),id){const key=`serverless_${id}_${contentType}`,params={content_type:contentType,"sys.id":id,include:10};locale&&locale!==defaultLocale&&(params.locale=locale,paramLocales[0]=locale);const data=await getContentfulData(key,params);let{items:items}=data;items=applyFilters("contentfulData",items,{...contentfulDataFilterArgs,contentType:contentType}),allData.content[contentType]=items}}if(!isServerless){const partial=config.partialTypes;for(const contentType of partial){const key=`all_${contentType}`;let newItems=[];for(const locale of paramLocales){const params={content_type:contentType};locale&&locale!==defaultLocale&&(params.locale=locale);const newData=await getContentfulData(key,params);let{items:items}=newData;items=applyFilters("contentfulData",items,{...contentfulDataFilterArgs,contentType:contentType}),newItems=[...newItems,...items]}allData[contentType]=newItems}}if(!isServerless&&!isPreview){const whole=config.wholeTypes;for(const contentType of whole){const key=`all_${contentType}`;let newItems=[];for(const locale of paramLocales){const params={content_type:contentType,include:10};locale&&locale!==defaultLocale&&(params.locale=locale);const newData=await getContentfulData(key,params);let{items:items}=newData;items=applyFilters("contentfulData",items,{...contentfulDataFilterArgs,contentType:contentType}),newItems=[...newItems,...items]}allData.content[contentType]=newItems}}return allData=applyFilters("allData",allData,{type:"contentful",serverlessData:serverlessData,previewData:previewData}),allData};export{getContentfulData,getAllContentfulData};

package/lib/contentful/contentfulDataNormal.d.ts

@@ -0,0 +1,4 @@
+import type { ContentfulDataItem } from './contentfulDataTypes.js';
+import type { RenderItem } from '../render/renderTypes.js';
+declare const normalizeContentfulData: (data: ContentfulDataItem[], _newData?: RenderItem[]) => RenderItem[];
+export { normalizeContentfulData };

package/lib/contentful/contentfulDataNormal.js

@@ -0,0 +1 @@
+import{normalizeContentType}from"../utils/contentType/contentType.js";import{isArrayStrict}from"../utils/array/array.js";import{isObjectStrict}from"../utils/object/object.js";import{isString,isStringStrict}from"../utils/string/string.js";import{getObjectKeys}from"../utils/object/objectUtils.js";import{isNumber}from"../utils/number/number.js";import{config}from"../config/config.js";const getTag=(type="text")=>({br:"br",hr:"hr",paragraph:"p",blockquote:"blockquote",bold:"b",italic:"i",underline:"u",superscript:"sup",subscript:"sub",code:"code",hyperlink:"a","entry-hyperlink":"a","asset-hyperlink":"a","heading-1":"h1","heading-2":"h2","heading-3":"h3","heading-4":"h4","heading-5":"h5","heading-6":"h6","list-item":"li","unordered-list":"ul","ordered-list":"ol",table:"table","table-row":"tr","table-cell":"td","table-header-cell":"th"}[type]||""),normalizeRichText=items=>{const newItems=[];return items.forEach(item=>{if(!isObjectStrict(item))return;const{nodeType:nodeType,data:data,value:value,marks:marks,content:content}=item,tag=getTag(nodeType);let contentValue,link,internalLink;if(isStringStrict(value)&&(contentValue=value,contentValue=contentValue.replace(/\n/g,"<br>"),isArrayStrict(marks))){const markTags=marks.map(m=>getTag(m.type));contentValue=`${markTags.map(m=>`<${m}>`).join("")}${value}${markTags.map(m=>`</${m}>`).join("")}`}if(isStringStrict(content)&&(contentValue=content),isArrayStrict(content)&&(contentValue=normalizeRichText(content)),isObjectStrict(data)&&(link=isString(data.uri)?data.uri:"",isObjectStrict(data.target))){const target=data.target;"entry-hyperlink"!==nodeType&&"embedded-entry-inline"!==nodeType||(internalLink=target);const url=target.fields?.file?.url;"asset-hyperlink"===nodeType&&isString(url)&&(link=`https:${url}`)}if(!contentValue)return;const newItem={content:contentValue};return isStringStrict(tag)&&(newItem.tag=tag),isStringStrict(link)&&(newItem.link=link),isObjectStrict(internalLink)&&(newItem.internalLink=normalizeItem(internalLink,[],!0)),newItems.push(newItem)}),newItems},normalizeFile=(file,fields)=>{const type=isString(file.contentType)?file.contentType:"",format=type?type.split("/")[1]:"";return{url:isString(file.url)?`https:${file.url}`:"",name:isString(file.fileName)?file.fileName:"",alt:isString(fields.description)?fields.description:"",width:isNumber(file.details?.image?.width)?file.details.image.width:0,height:isNumber(file.details?.image?.height)?file.details.image.height:0,size:isNumber(file.details?.size)?file.details.size:0,format:"jpeg"===format?"jpg":format,type:type}},normalizeItem=(item,data,isInternalLink=!1)=>{let newItem={};const itemCopy={...item};isString(itemCopy.sys?.id)&&(newItem.id=itemCopy.sys.id),isStringStrict(itemCopy.sys?.locale)&&(newItem.locale=itemCopy.sys.locale);let type="";if(isString(itemCopy.sys?.type)&&(type=itemCopy.sys.type),isString(itemCopy.sys?.contentType?.sys?.id)&&(type=itemCopy.sys.contentType.sys.id),type&&"Link"!==type&&(newItem.contentType=normalizeContentType(type),isString(config.renderTypes[type])&&(newItem.renderType=config.renderTypes[type])),isArrayStrict(itemCopy.metadata?.tags)&&(newItem.metadata={tags:itemCopy.metadata.tags.map(t=>({id:isString(t.sys?.id)?t.sys.id:""}))}),isObjectStrict(itemCopy.fields)){const fields=itemCopy.fields,file=fields.file;if(isObjectStrict(file))return Object.assign(normalizeFile(file,fields),newItem);getObjectKeys(fields).forEach(prop=>{const field=fields[prop];if("content"!==prop||!isInternalLink)if(isObjectStrict(field))if("document"===field.nodeType){const{content:content}=field;isArrayStrict(content)&&(newItem[prop]=content.map(c=>isObjectStrict(c)?normalizeItem(c,data,isInternalLink):c))}else newItem[prop]=normalizeItem(field,data,"internalLink"===prop);else isArrayStrict(field)?newItem[prop]=field.map(f=>isObjectStrict(f)?normalizeItem(f,data,isInternalLink):f):newItem[prop]=field})}if(isString(itemCopy.nodeType)){const nodeType=itemCopy.nodeType;if("embedded-entry-block"===nodeType||"embedded-asset-block"===nodeType){const content=isObjectStrict(itemCopy.data?.target)?itemCopy.data.target:{};newItem=normalizeItem(content,data,isInternalLink)}else newItem.renderType="richText",newItem.tag=getTag(itemCopy.nodeType),isString(itemCopy.content)&&(newItem.content=itemCopy.content),isArrayStrict(itemCopy.content)&&(newItem.content=normalizeRichText(itemCopy.content))}return newItem},normalizeContentfulData=(data,_newData=[])=>isArrayStrict(data)?(data.forEach(item=>{isObjectStrict(item)&&_newData.push(normalizeItem(item,_newData))}),_newData):[];export{normalizeContentfulData};

package/lib/contentful/contentfulDataTypes.d.ts

@@ -0,0 +1,78 @@
+import type { Generic } from '../global/globalTypes.js';
+import type { RenderServerlessData, RenderPreviewData } from '../render/renderTypes.js';
+export type ContentfulDataParams = Record<string, string | number | boolean>;
+interface ContentfulDataErrorSys {
+    type: string;
+    id: string;
+}
+export interface ContentfulDataError {
+    message: string;
+    sys: ContentfulDataErrorSys;
+}
+export interface ContentfulData {
+    items: ContentfulDataItem[];
+    total: number;
+    limit: number;
+    skip: number;
+}
+interface ContentfulDataId {
+    id?: string;
+}
+export interface ContentfulDataTag {
+    sys?: ContentfulDataId;
+}
+interface ContentfulDataMeta {
+    tags?: ContentfulDataTag[];
+}
+export interface ContentfulDataMark {
+    type: string;
+}
+interface ContentfulDataFileImage {
+    width?: number;
+    height?: number;
+}
+interface ContentfulDataFileDetails {
+    size?: number;
+    image?: ContentfulDataFileImage;
+}
+export interface ContentfulDataFile {
+    url?: string;
+    contentType?: string;
+    fileName?: string;
+    details?: ContentfulDataFileDetails;
+}
+export interface ContentfulDataFields extends Generic {
+    content?: ContentfulDataItem[] | ContentfulDataItem;
+    internalLink?: ContentfulDataItem;
+    file?: ContentfulDataFile;
+    description?: string;
+    title?: string;
+}
+interface ContentfulDataSysType {
+    sys?: ContentfulDataId;
+}
+export interface ContentfulDataSys {
+    id?: string;
+    type?: string;
+    locale?: string;
+    contentType?: ContentfulDataSysType;
+}
+interface ContentfulDataDatum {
+    uri?: string;
+    target?: ContentfulDataItem;
+}
+export interface ContentfulDataItem {
+    value?: string;
+    nodeType?: string;
+    marks?: ContentfulDataMark[];
+    data?: ContentfulDataDatum;
+    content?: ContentfulDataItem[] | string;
+    metadata?: ContentfulDataMeta;
+    sys?: ContentfulDataSys;
+    fields?: ContentfulDataFields;
+}
+export interface AllContentfulDataArgs {
+    serverlessData?: RenderServerlessData;
+    previewData?: RenderPreviewData;
+}
+export {};

package/lib/contentful/contentfulDataTypes.js

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

package/lib/filters/filters.d.ts

@@ -0,0 +1,8 @@
+import type { Filters, FilterMap, FilterReturnType } from './filtersTypes.js';
+declare let filters: FilterMap;
+declare const addFilter: <T extends keyof Filters>(name: T, filter: Filters[T]) => boolean;
+declare const removeFilter: <T extends keyof Filters>(name: T, filter: Filters[T]) => boolean;
+declare const applyFilters: <T, V extends boolean = false>(name: string, value: T, args?: unknown, isAsync?: V) => FilterReturnType<T, V>;
+declare const resetFilters: () => void;
+declare const setFilters: (args: Partial<Filters>) => boolean;
+export { filters, addFilter, removeFilter, applyFilters, resetFilters, setFilters };

package/lib/filters/filters.js

@@ -0,0 +1 @@
+import{isSet,isSetStrict}from"../utils/set/set.js";import{isStringStrict}from"../utils/string/string.js";import{isObjectStrict}from"../utils/object/object.js";import{isFunction}from"../utils/function/function.js";let filters=new Map([["columnProps",new Set],["containerProps",new Set],["formOptionProps",new Set],["formFieldProps",new Set],["formProps",new Set],["richTextProps",new Set],["richTextOutput",new Set],["richTextContentItem",new Set],["richTextContent",new Set],["richTextContentOutput",new Set],["renderItem",new Set],["renderItemData",new Set],["renderContent",new Set],["serverlessResult",new Set],["contactResult",new Set],["cacheData",new Set],["storeData",new Set],["contentfulData",new Set],["wordpressData",new Set],["localData",new Set],["allData",new Set],["slugParts",new Set],["slug",new Set]]);const addFilter=(name,filter)=>!(!isStringStrict(name)||!isFunction(filter))&&(isSet(filters.get(name))||filters.set(name,new Set),filters.get(name)?.add(filter),!0),removeFilter=(name,filter)=>{if(!isStringStrict(name)||!isFunction(filter))return!1;const filterSet=filters.get(name);return!!isSet(filterSet)&&filterSet.delete(filter)},applySequentially=async(callbacks,value,args)=>{for(const callback of callbacks)value=await callback(value,args);return value},applyFilters=(name,value,args,isAsync=!1)=>{const filterSet=filters.get(name);if(!isSetStrict(filterSet))return value;const callbacks=[];for(const callback of filterSet.values())isAsync?callbacks.push(callback):value=callback(value,args);return isAsync?applySequentially(callbacks,value,args).then(newValue=>newValue).catch(()=>value):value},resetFilters=()=>{filters=new Map([["columnProps",new Set],["containerProps",new Set],["formOptionProps",new Set],["formFieldProps",new Set],["formProps",new Set],["richTextProps",new Set],["richTextOutput",new Set],["richTextContentItem",new Set],["richTextContent",new Set],["richTextContentOutput",new Set],["renderItem",new Set],["renderItemData",new Set],["renderContent",new Set],["serverlessResult",new Set],["contactResult",new Set],["cacheData",new Set],["storeData",new Set],["contentfulData",new Set],["wordpressData",new Set],["localData",new Set],["allData",new Set],["slugParts",new Set],["slug",new Set]])},setFilters=args=>{if(!isObjectStrict(args))return!1;const newFilters=Object.entries(args);return!!newFilters.length&&(resetFilters(),newFilters.forEach(([name,filter])=>{filter&&addFilter(name,filter)}),!0)};export{filters,addFilter,removeFilter,applyFilters,resetFilters,setFilters};

package/lib/filters/filtersTypes.d.ts

@@ -0,0 +1,60 @@
+import type { GenericFunction } from '../global/globalTypes.js';
+import type { ColumnPropsFilter } from '../layouts/Column/ColumnTypes.js';
+import type { ContainerPropsFilter } from '../layouts/Container/ContainerTypes.js';
+import type { FormPropsFilter, FormFieldPropsFilter, FormOptionPropsFilter } from '../objects/Form/FormTypes.js';
+import type { ServerlessResultFilter } from '../serverless/serverlessTypes.js';
+import type { ContactResultFilter } from '../serverless/Contact/ContactTypes.js';
+import type { LinkSlugPartsFilter, LinkSlugFilter } from '../utils/link/linkTypes.js';
+import type { RichTextPropsFilter, RichTextOutputFilter, RichTextContentItemFilter, RichTextContentFilter, RichTextContentOutputFilter } from '../text/RichText/RichTextTypes.js';
+import type { RenderItem, RenderItemFilter, RenderItemDataFilter, RenderContentFilter, RenderServerlessData, RenderPreviewData, RenderAllData, RenderData } from '../render/renderTypes.js';
+export interface DataFilterArgs {
+    serverlessData?: RenderServerlessData;
+    previewData?: RenderPreviewData;
+    contentType?: string;
+}
+export interface AllDataFilterArgs {
+    type: 'contentful' | 'wordpress' | 'local';
+    serverlessData?: RenderServerlessData;
+    previewData?: RenderPreviewData;
+}
+export type ContentfulDataFilter = (data: RenderItem[], args: DataFilterArgs) => RenderItem[];
+export type WordpressDataFilter = (data: RenderItem[], args: DataFilterArgs) => RenderItem[];
+export type LocalDataFilter = (data: RenderItem) => RenderItem;
+export type AllDataFilter = (allData: RenderAllData, args: AllDataFilterArgs) => RenderAllData;
+export interface CacheData extends RenderData {
+    data?: Record<string, RenderItem>;
+}
+export interface CacheDataFilterArgs {
+    key: string;
+    type: string;
+    data?: CacheData;
+}
+export type CacheDataFilter = (data: CacheData, args: CacheDataFilterArgs) => Promise<CacheData | undefined>;
+export type StoreDataFilter = (data: object | undefined, type: string) => Promise<object | undefined>;
+export interface Filters extends Record<string, GenericFunction> {
+    columnProps: ColumnPropsFilter;
+    containerProps: ContainerPropsFilter;
+    formOptionProps: FormOptionPropsFilter;
+    formFieldProps: FormFieldPropsFilter;
+    formProps: FormPropsFilter;
+    richTextProps: RichTextPropsFilter;
+    richTextOutput: RichTextOutputFilter;
+    richTextContentItem: RichTextContentItemFilter;
+    richTextContent: RichTextContentFilter;
+    richTextContentOutput: RichTextContentOutputFilter;
+    renderItem: RenderItemFilter;
+    renderItemData: RenderItemDataFilter;
+    renderContent: RenderContentFilter;
+    serverlessResult: ServerlessResultFilter;
+    contactResult: ContactResultFilter;
+    cacheData: CacheDataFilter;
+    storeData: StoreDataFilter;
+    contentfulData: ContentfulDataFilter;
+    wordpressData: WordpressDataFilter;
+    localData: LocalDataFilter;
+    allData: AllDataFilter;
+    slugParts: LinkSlugPartsFilter;
+    slug: LinkSlugFilter;
+}
+export type FilterMap = Map<string, Set<GenericFunction>> & Map<'columnProps' | 'containerProps' | 'formOptionProps' | 'formFieldProps' | 'formProps' | 'richTextProps' | 'richTextOutput' | 'richTextContentItem' | 'richTextContent' | 'richTextContentOutput' | 'renderItem' | 'renderItemData' | 'renderContent' | 'serverlessResult' | 'contactResult' | 'cacheData' | 'storeData' | 'contentfulData' | 'wordpressData' | 'localData' | 'allData' | 'slugParts' | 'slug', Set<ColumnPropsFilter | ContainerPropsFilter | FormOptionPropsFilter | FormFieldPropsFilter | FormPropsFilter | RichTextPropsFilter | RichTextOutputFilter | RichTextContentItemFilter | RichTextContentFilter | RichTextContentOutputFilter | RenderItemFilter | RenderItemDataFilter | RenderContentFilter | ServerlessResultFilter | ContactResultFilter | CacheDataFilter | StoreDataFilter | ContentfulDataFilter | WordpressDataFilter | LocalDataFilter | AllDataFilter | LinkSlugPartsFilter | LinkSlugFilter>>;
+export type FilterReturnType<T, V extends false | true> = V extends true ? Promise<T> : T;

package/lib/filters/filtersTypes.js

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

package/lib/global/globalTypes.d.ts

@@ -0,0 +1,34 @@
+export interface Taxonomy {
+    id: string;
+    title: string;
+    contentTypes: string[];
+    slug?: string;
+    link?: string;
+    isPage?: boolean;
+    usePrimaryContentTypeSlug?: boolean;
+}
+export interface InternalLink extends Generic {
+    id?: string;
+    contentType?: string;
+    slug?: string;
+    link?: string;
+    title?: string;
+    taxonomy?: Taxonomy;
+}
+export interface Parent extends InternalLink {
+    id: string;
+    slug: string;
+    title: string;
+}
+export interface ParentArgs<T = Generic> {
+    renderType: string;
+    args: T;
+}
+export interface RefString {
+    ref: string;
+}
+export type Source = 'cms' | 'local' | (string & Record<never, never>);
+export type Generic = Record<string, unknown>;
+export type GenericFunction<T extends (...args: any[]) => any = (...args: any[]) => any> = T;
+export type GenericStrings = Record<string, string>;
+export type GenericNumbers = Record<string, number>;

package/lib/global/globalTypes.js

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

package/lib/layouts/Column/Column.d.ts

@@ -0,0 +1,3 @@
+import type { ColumnProps } from './ColumnTypes.js';
+declare const Column: (props: ColumnProps) => string[];
+export { Column };

package/lib/layouts/Column/Column.js

@@ -0,0 +1 @@
+import{applyFilters}from"../../filters/filters.js";import{isStringStrict}from"../../utils/string/string.js";import{isObjectStrict}from"../../utils/object/object.js";const Column=props=>{if(!isObjectStrict(props))return[];props=applyFilters("columnProps",props);const{args:args}=props,{tag:tag="div",classes:classes,style:style,attr:attr}=isObjectStrict(args)?args:{};if(!isStringStrict(tag))return[];let styles="";isStringStrict(style)&&(styles=` style="${style}"`);let attrs="";return isStringStrict(classes)&&(attrs+=` class="${classes}"`),isStringStrict(attr)&&(attrs+=` ${attr}`),[`<${tag}${attrs}${styles}>`,`</${tag}>`]};export{Column};

package/lib/layouts/Column/ColumnTypes.d.ts

@@ -0,0 +1,16 @@
+import type { Generic } from '../../global/globalTypes.js';
+import type { RenderFunctionArgs, RenderItem } from '../../render/renderTypes.js';
+export interface ColumnArgs<T = any, W = any> extends Generic {
+    tag?: string & T;
+    width?: (string | number) & W;
+    widthSmall?: (string | number) & W;
+    widthMedium?: (string | number) & W;
+    widthLarge?: (string | number) & W;
+    classes?: string;
+    style?: string;
+    attr?: string;
+}
+export interface ColumnProps<A = ColumnArgs, R = RenderItem> extends RenderFunctionArgs<A, R> {
+    args: ColumnArgs & A;
+}
+export type ColumnPropsFilter<A = ColumnArgs, R = RenderItem> = (props: ColumnProps<A, R>) => ColumnProps<A, R>;

package/lib/layouts/Column/ColumnTypes.js

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

package/lib/layouts/Container/Container.d.ts

@@ -0,0 +1,3 @@
+import type { ContainerProps } from './ContainerTypes.js';
+declare const Container: (props: ContainerProps) => string[];
+export { Container };

package/lib/layouts/Container/Container.js

@@ -0,0 +1 @@
+import{applyFilters}from"../../filters/filters.js";import{isObjectStrict}from"../../utils/object/object.js";import{isStringStrict}from"../../utils/string/string.js";const Container=props=>{if(!isObjectStrict(props))return[];props=applyFilters("containerProps",props);const{args:args}=props,{tag:tag="div",layoutClasses:layoutClasses,classes:classes,style:style,attr:attr,nest:nest=!1}=isObjectStrict(args)?args:{};if(!isStringStrict(tag))return[];const isSemanticParent=new Set(["ul","ol","dl","figure"]).has(tag),hasLayoutClasses=isStringStrict(layoutClasses),hasClasses=isStringStrict(classes),attrs=[],innerAttrs=[],isNested=nest&&hasLayoutClasses,isNestedSemanticParent=isSemanticParent&&isNested,innerClassesArr=[];isNested&&hasLayoutClasses&&innerClassesArr.push(layoutClasses);const outerClassesArr=[];isNested&&hasClasses&&outerClassesArr.push(classes),!isNested&&hasClasses&&outerClassesArr.push(classes),!isNested&&hasLayoutClasses&&outerClassesArr.push(layoutClasses),outerClassesArr.length&&attrs.push(`class="${outerClassesArr.join(" ")}"`),innerClassesArr.length&&innerAttrs.push(`class="${innerClassesArr.join(" ")}"`);const att=isNestedSemanticParent?innerAttrs:attrs;isStringStrict(attr)&&att.push(attr),isStringStrict(style)&&att.push(`style="${style}"`);let outerTag=tag,innerTag="";isNested&&(outerTag=isSemanticParent?"div":tag,innerTag=isSemanticParent?tag:"div");let start=`<${outerTag}${attrs.length?` ${attrs.join(" ")}`:""}>`,end=`</${outerTag}>`;return innerTag&&(start=`${start}<${innerTag} ${innerAttrs.join(" ")}>`,end=`</${innerTag}>${end}`),[start,end]};export{Container};

package/lib/layouts/Container/ContainerTypes.d.ts

@@ -0,0 +1,15 @@
+import type { Generic } from '../../global/globalTypes.js';
+import type { RenderFunctionArgs, RenderItem } from '../../render/renderTypes.js';
+export interface ContainerArgs<T = any, M = any> extends Generic {
+    tag?: string & T;
+    maxWidth?: (string | number) & M;
+    layoutClasses?: string;
+    classes?: string;
+    style?: string;
+    attr?: string;
+    nest?: boolean;
+}
+export interface ContainerProps<A = ContainerArgs, R = RenderItem> extends RenderFunctionArgs<A, R> {
+    args: ContainerArgs & A;
+}
+export type ContainerPropsFilter<A = ContainerArgs, R = RenderItem> = (props: ContainerProps<A, R>) => ContainerProps<A, R>;

package/lib/layouts/Container/ContainerTypes.js

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

package/lib/local/localData.d.ts

@@ -0,0 +1,5 @@
+import type { LocalData, LocalDataArgs, AllLocalDataArgs } from './localDataTypes.js';
+import type { RenderAllData } from '../render/renderTypes.js';
+declare const getLocalData: (args: LocalDataArgs) => Promise<LocalData>;
+declare const getAllLocalData: (args?: AllLocalDataArgs) => Promise<RenderAllData | undefined>;
+export { getLocalData, getAllLocalData };

package/lib/local/localData.js

@@ -0,0 +1 @@
+import{readdir,readFile}from"node:fs/promises";import{extname,basename,resolve}from"node:path";import{isObject,isObjectStrict}from"../utils/object/object.js";import{isStringStrict}from"../utils/string/string.js";import{applyFilters}from"../filters/filters.js";import{getJson}from"../utils/json/json.js";import{config}from"../config/config.js";import{normalizeLocalData}from"./localDataNormal.js";const getLocalData=async args=>{if(!isObjectStrict(args))throw new Error("No args");const{key:key,refProps:refProps,imageProps:imageProps,unsetProps:unsetProps}=args;if(!isStringStrict(key))throw new Error("No key");if(config.env.cache){const cacheDataFilterArgs={key:key,type:"get"},cacheData=await applyFilters("cacheData",void 0,cacheDataFilterArgs,!0),cacheItems=cacheData?.data;if(isObject(cacheItems))return structuredClone(cacheItems)}const dir=config.local.dir,data={};let hasData=!1;const files=await readdir(resolve(dir));for(const file of files){const fileExt=extname(file),fileName=basename(file,fileExt);if(".json"!==fileExt)continue;const fileContents=await readFile(resolve(dir,file),{encoding:"utf8"}),fileJson=getJson(fileContents);fileJson&&(data[fileName]=fileJson,hasData=!0)}if(!hasData)throw new Error("No data");const newData=normalizeLocalData(data,refProps,imageProps,unsetProps);if(config.env.cache){const cacheDataFilterArgs={key:key,type:"set",data:data};await applyFilters("cacheData",{data:newData},cacheDataFilterArgs,!0)}return newData},getAllLocalData=async args=>{const data=await getLocalData({key:"all_file_data",refProps:args?.refProps,imageProps:args?.imageProps,unsetProps:args?.unsetProps});let allData={navigationItem:[],navigation:[],content:{page:[]}};for(const[,value]of Object.entries(data)){const{contentType:contentType}=value;if(!isStringStrict(contentType))continue;const isPartial=config.partialTypes.includes(contentType),isWhole=config.wholeTypes.includes(contentType);if(!isPartial&&!isWhole)continue;const val=applyFilters("localData",value);isPartial&&(null==allData[contentType]&&(allData[contentType]=[]),allData[contentType].push(val)),isWhole&&(null==allData.content[contentType]&&(allData.content[contentType]=[]),allData.content[contentType].push(val))}return allData=applyFilters("allData",allData,{type:"local"}),allData};export{getLocalData,getAllLocalData};

package/lib/local/localDataNormal.d.ts

@@ -0,0 +1,3 @@
+import type { LocalData } from './localDataTypes.js';
+declare const normalizeLocalData: (data: LocalData, refProps?: string[], imageProps?: string[], unsetProps?: string[]) => LocalData;
+export { normalizeLocalData };

package/lib/local/localDataNormal.js

@@ -0,0 +1 @@
+import{isObject,isObjectStrict}from"../utils/object/object.js";import{isArray,isArrayStrict}from"../utils/array/array.js";import{isStringStrict}from"../utils/string/string.js";import{getStoreItem}from"../store/store.js";const normalizeLocalRefs=(data,refData,imageData,refProps=["internalLink","term","taxonomy"],imageProps=["image"],unsetProps=["content"],contentType)=>{const newData=isArray(data)?[]:{},isTemplate="contentTemplate"===data.renderType,isNavigation="navigation"===contentType,isNavigationItem="navigationItem"===contentType;for(const[key,value]of Object.entries(data)){const isRef=refProps.includes(key),isImage=imageProps.includes(key),isStr=isStringStrict(value),isArr=isArrayStrict(value);let newValue=value;isTemplate&&"content"===key&&isArr&&(newValue=value.map(item=>isStringStrict(item)?{...refData[item]}:item)),(isNavigation&&"items"===key||isNavigationItem&&"children"===key)&&isArr&&(newValue=value.map(id=>isStringStrict(id)?{id:id,title:refData[id]?.title}:null).filter(Boolean)),isImage&&isStr&&(newValue=imageData[value]?{...imageData[value]}:null),isRef&&isStr&&(newValue={...refData[value]},unsetProps.forEach(prop=>{newValue[prop]&&(newValue[prop]=void 0)})),isRef&&isArrayStrict(value)&&(newValue=value.map(refKey=>{if(!isStringStrict(refKey))return null;const ref=refData[refKey];if(!isObjectStrict(ref))return null;const newRef={...ref};return unsetProps.forEach(prop=>{newRef[prop]&&(newRef[prop]=void 0)}),newRef}).filter(Boolean)),isObject(newValue)&&(newValue=normalizeLocalRefs(newValue,refData,imageData,refProps,imageProps,unsetProps)),newData[key]=newValue}return newData},normalizeLocalData=(data,refProps,imageProps,unsetProps)=>{const newData={},imageMeta=getStoreItem("imageMeta"),refData={};for(const[key,item]of Object.entries(data))isObjectStrict(item)&&(refData[key]={id:key,...item});for(const[key,item]of Object.entries(refData))newData[key]=normalizeLocalRefs(item,refData,imageMeta,refProps,imageProps,unsetProps,item.contentType);return newData};export{normalizeLocalData};

package/lib/local/localDataTypes.d.ts

@@ -0,0 +1,14 @@
+import type { RenderItem } from '../render/renderTypes.js';
+export type LocalData = Record<string, RenderItem>;
+export type LocalDataItem = Record<string | number, unknown>;
+export interface LocalDataArgs {
+    key: string;
+    refProps?: string[];
+    imageProps?: string[];
+    unsetProps?: string[];
+}
+export interface AllLocalDataArgs {
+    refProps?: string[];
+    imageProps?: string[];
+    unsetProps?: string[];
+}

package/lib/local/localDataTypes.js

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

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

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

package/lib/objects/Form/Form.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 Form=props=>{if(!isObjectStrict(props))return[];props=applyFilters("formProps",props);const{args:args}=props,{id:id,formTag:formTag="form",formClasses:formClasses,formAttr:formAttr,fields:fields="",fieldsClasses:fieldsClasses,fieldsAttr:fieldsAttr,submitFieldClasses:submitFieldClasses,submitFieldAttr:submitFieldAttr,submitLabel:submitLabel="Submit",submitClasses:submitClasses,submitAttr:submitAttr,honeypotName:honeypotName,honeypotFieldClasses:honeypotFieldClasses,honeypotFieldAttr:honeypotFieldAttr,honeypotLabelClasses:honeypotLabelClasses,honeypotLabel:honeypotLabel="Website",honeypotClasses:honeypotClasses,honeypotAttr:honeypotAttr}=isObjectStrict(args)?args:{};if(!isStringStrict(id)||!isStringStrict(formTag)||!isStringStrict(submitLabel))return[];const formAttrs=(isStringStrict(formClasses)?` class="${formClasses}"`:"")+(isStringStrict(formAttr)?` ${formAttr}`:""),fieldsTag="form"===formTag?"div":"form",fieldsAttrs=(isStringStrict(fieldsClasses)?` class="${fieldsClasses}"`:"")+(isStringStrict(fieldsAttr)?` ${fieldsAttr}`:"");let honeypotOutput="";if(isStringStrict(honeypotName)){const honeypotId=uuid(),honeypotFieldAttrs=(isStringStrict(honeypotFieldClasses)?` class="${honeypotFieldClasses}"`:"")+(isStringStrict(honeypotFieldAttr)?` ${honeypotFieldAttr}`:""),honeypotAttrs=(isStringStrict(honeypotClasses)?` class="${honeypotClasses}"`:"")+(isStringStrict(honeypotAttr)?` ${honeypotAttr}`:"");honeypotOutput=`\n      <div${honeypotFieldAttrs}>\n        <label for="${honeypotId}"${isStringStrict(honeypotLabelClasses)?` class="${honeypotLabelClasses}"`:""}>\n          ${honeypotLabel}\n        </label>\n        <input type="url" name="${honeypotName}" id="${honeypotId}" autocomplete="off"${honeypotAttrs}>\n      </div>\n    `}return[`\n    <${formTag} id="${id}"${formAttrs}>\n      <${fieldsTag}${fieldsAttrs}>`,`${fields}${honeypotOutput}\n        <div${(isStringStrict(submitFieldClasses)?` class="${submitFieldClasses}"`:"")+(isStringStrict(submitFieldAttr)?` ${submitFieldAttr}`:"")}>\n          <button type="submit"${(isStringStrict(submitClasses)?` class="${submitClasses}"`:"")+(isStringStrict(submitAttr)?` ${submitAttr}`:"")}>\n            ${submitLabel}\n          </button>\n        </div>\n      </${fieldsTag}>\n    </${formTag}>\n  `]};export{Form};

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

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