@pro-laico/create-atomic-payload 0.1.4

package/template/src/blocks/actions/cookieConsent/toDA/options.ts

@@ -0,0 +1,19 @@
+import { z } from '@/ts/zap'
+import type { ActionProcessFunction } from '@/ts/types'
+
+const processFunction: ActionProcessFunction<'ActCCToDA'> = ({ listen, key, changeKey, data }) => {
+  let value: z.ap.Type<'AttCCToDA'>['listen']
+
+  switch (listen) {
+    case 'preference':
+      value = { listen: 'preference', key: key || 'functional' }
+      break
+    default:
+      value = { listen: listen }
+  }
+
+  const Att: z.ap.Type<'AttCCToDA'> = { type: 'AttCCToDA', listen: value, changeKey }
+  data.attributers.push(Att)
+}
+
+export const ActCCToDA = { processFunction }

package/template/src/blocks/actions/dynamicStore/boolean/set/block.ts

@@ -0,0 +1,15 @@
+import type { Block } from 'payload'
+import { KeyTextField, SetDataField, PersistedField, InitialValueCheckboxField } from '@/fields/actions'
+
+export const ActDSSetBool: Block = {
+  slug: 'ActDSSetBool',
+  interfaceName: 'ActDSSetBool',
+  admin: { group: 'Dynamic Store' },
+  labels: { singular: 'Set Boolean', plural: 'Set Boolean' },
+  fields: [
+    KeyTextField({ admin: { width: '25%' } }),
+    PersistedField({ admin: { width: '25%' } }),
+    SetDataField({ admin: { width: '25%' } }),
+    InitialValueCheckboxField({ admin: { width: '25%' } }),
+  ],
+}

package/template/src/blocks/actions/dynamicStore/boolean/set/filter.ts

@@ -0,0 +1,4 @@
+import { ActionBlockFilter } from '@/ts/types/actions'
+
+export const ActDSSetBool = ({ blockType, type, placement }: ActionBlockFilter) =>
+  Boolean(blockType === 'AtomicChild' && type === 'button' && placement === 'trigger')

package/template/src/blocks/actions/dynamicStore/boolean/set/options.ts

@@ -0,0 +1,18 @@
+import { z } from '@/ts/zap'
+import type { ActionProcessFunction, ActionSetKeyInitialByAction } from '@/ts/types'
+
+const setKeyInitialByAction: ActionSetKeyInitialByAction<'ActDSSetBool'> = (props) => {
+  const { key, initialValue, persisted } = props.actionBlock
+  return { key, initialValue, persisted }
+}
+
+const processFunction: ActionProcessFunction<'ActDSSetBool'> = ({ key, initialValue, persisted, setDA, data }) => {
+  const Run: z.ap.Type<'RunSetBool'> = { type: 'RunSetBool', key, initialValue, persisted }
+  data.runners.push(Run)
+  if (setDA) {
+    const Att: z.ap.Type<'AttBoolToDA'> = { type: 'AttBoolToDA', key, initialValue, persisted }
+    data.attributers.push(Att)
+  }
+}
+
+export const ActDSSetBool = { setKeyInitialByAction, processFunction }

package/template/src/blocks/actions/dynamicStore/boolean/toDA/block.ts

@@ -0,0 +1,10 @@
+import type { Block } from 'payload'
+import { ChangeKeyField, KeyTextField } from '@/fields/actions'
+
+export const ActDSBoolToDA: Block = {
+  slug: 'ActDSBoolToDA',
+  interfaceName: 'ActDSBoolToDA',
+  admin: { group: 'Dynamic Store' },
+  labels: { singular: 'Boolean To Data Attribute', plural: 'Boolean To Data Attribute' },
+  fields: [{ type: 'row', fields: [KeyTextField({ admin: { width: '25%' } }), ChangeKeyField({ admin: { width: '25%' } })] }],
+}

package/template/src/blocks/actions/dynamicStore/boolean/toDA/filter.ts

@@ -0,0 +1,3 @@
+import { ActionBlockFilter } from '@/ts/types/actions'
+
+export const ActDSBoolToDA = (_: ActionBlockFilter) => true

package/template/src/blocks/actions/dynamicStore/boolean/toDA/options.ts

@@ -0,0 +1,12 @@
+import { z } from '@/ts/zap'
+import type { ActionProcessFunction } from '@/ts/types'
+
+const processFunction: ActionProcessFunction<'ActDSBoolToDA'> = ({ key, changeKey, initialValuesMap, data }) => {
+  const { initialValue, persisted } = initialValuesMap.get(key) || {}
+  if (typeof initialValue !== 'boolean') return
+
+  const Att: z.ap.Type<'AttBoolToDA'> = { type: 'AttBoolToDA', key, changeKey, initialValue, persisted }
+  data.attributers.push(Att)
+}
+
+export const ActDSBoolToDA = { processFunction }

package/template/src/blocks/actions/dynamicStore/text/cycle/block.ts

@@ -0,0 +1,41 @@
+import type { Block } from 'payload'
+import { APField } from '@/fields/apf'
+import { KeyTextField } from '@/fields/actions'
+import { InitialValueCheckboxField, PersistedField, SetDataField } from '@/fields/actions'
+
+export const ActDSCycleText: Block = {
+  slug: 'ActDSCycleText',
+  interfaceName: 'ActDSCycleText',
+  admin: { group: 'Dynamic Store' },
+  labels: { singular: 'Cycle Text', plural: 'Cycle Text' },
+  fields: [
+    {
+      type: 'group',
+      label: 'Settings',
+      admin: { hideGutter: true },
+      fields: [
+        {
+          type: 'row',
+          fields: [KeyTextField({ admin: { width: '25%' } }), PersistedField({ admin: { width: '25%' } }), SetDataField({ admin: { width: '25%' } })],
+        },
+      ],
+    },
+    {
+      name: 'textArray',
+      type: 'array',
+      label: 'Values',
+      required: true,
+      minRows: 2,
+      fields: [
+        InitialValueCheckboxField({ admin: { width: '25%' } }),
+        APField({
+          name: 'value',
+          type: 'text',
+          apf: ['actions'],
+          required: true,
+          admin: { width: '75%', description: 'The value to set the key to.' },
+        }),
+      ],
+    },
+  ],
+}

package/template/src/blocks/actions/dynamicStore/text/cycle/filter.ts

@@ -0,0 +1,4 @@
+import { ActionBlockFilter } from '@/ts/types/actions'
+
+export const ActDSCycleText = ({ blockType, type, placement }: ActionBlockFilter) =>
+  Boolean(blockType === 'AtomicChild' && type === 'button' && placement === 'trigger')

package/template/src/blocks/actions/dynamicStore/text/cycle/options.ts

@@ -0,0 +1,23 @@
+import { z } from '@/ts/zap'
+import type { ActionProcessFunction, ActionSetKeyInitialByAction } from '@/ts/types'
+
+const setKeyInitialByAction: ActionSetKeyInitialByAction<'ActDSCycleText'> = (props) => {
+  const { key, persisted, textArray } = props.actionBlock
+  const initialValue = textArray.find((item) => item.initialValue)?.value || textArray[0]?.value
+  return { key, initialValue, persisted }
+}
+
+const processFunction: ActionProcessFunction<'ActDSCycleText'> = ({ key, persisted, textArray, setDA, data }) => {
+  const initialValue = textArray.find((item) => item.initialValue)?.value || textArray[0]?.value
+  const cleanTextArray = textArray.map(({ id, ...rest }) => rest)
+
+  const Run: z.ap.Type<'RunCycleText'> = { type: 'RunCycleText', key, persisted, initialValue, textArray: cleanTextArray }
+  data.runners.push(Run)
+
+  if (setDA) {
+    const Att: z.ap.Type<'AttTextToDA'> = { type: 'AttTextToDA', key, persisted, initialValue }
+    data.attributers.push(Att)
+  }
+}
+
+export const ActDSCycleText = { setKeyInitialByAction, processFunction }

package/template/src/blocks/actions/dynamicStore/text/toDA/block.ts

@@ -0,0 +1,10 @@
+import type { Block } from 'payload'
+import { ChangeKeyField, KeyTextField } from '@/fields/actions'
+
+export const ActDSTextToDA: Block = {
+  slug: 'ActDSTextToDA',
+  interfaceName: 'ActDSTextToDA',
+  admin: { group: 'Dynamic Store' },
+  labels: { singular: 'Text To Data Attribute', plural: 'Text To Data Attribute' },
+  fields: [{ type: 'row', fields: [KeyTextField({ admin: { width: '25%' } }), ChangeKeyField({ admin: { width: '25%' } })] }],
+}

package/template/src/blocks/actions/dynamicStore/text/toDA/filter.ts

@@ -0,0 +1,3 @@
+import { ActionBlockFilter } from '@/ts/types/actions'
+
+export const ActDSTextToDA = (_: ActionBlockFilter) => true

package/template/src/blocks/actions/dynamicStore/text/toDA/options.ts

@@ -0,0 +1,12 @@
+import { z } from '@/ts/zap'
+import type { ActionProcessFunction } from '@/ts/types'
+
+const processFunction: ActionProcessFunction<'ActDSTextToDA'> = ({ key, changeKey, initialValuesMap, data }) => {
+  const { initialValue, persisted } = initialValuesMap.get(key) || {}
+  if (typeof initialValue !== 'string') return
+
+  const Att: z.ap.Type<'AttTextToDA'> = { type: 'AttTextToDA', key: changeKey || key, persisted, initialValue }
+  data.attributers.push(Att)
+}
+
+export const ActDSTextToDA = { processFunction }

package/template/src/blocks/actions/filters.ts

@@ -0,0 +1,27 @@
+import { ActSetTheme } from './theme/set/filter'
+import { ActResetForm } from './form/reset/filter'
+import { ActSubmitForm } from './form/submit/filter'
+import { ActSetCC } from './cookieConsent/set/filter'
+import { ActSetPortalOpen } from './portal/set/filter'
+import { ActCCToDA } from './cookieConsent/toDA/filter'
+import { ActFormErrorToDA } from './form/errorToDA/filter'
+import { ActFormStatusToDA } from './form/statusToDA/filter'
+import { ActDSTextToDA } from './dynamicStore/text/toDA/filter'
+import { ActDSSetBool } from './dynamicStore/boolean/set/filter'
+import { ActDSCycleText } from './dynamicStore/text/cycle/filter'
+import { ActDSBoolToDA } from './dynamicStore/boolean/toDA/filter'
+
+export const ActionFilters = {
+  ActSetCC,
+  ActCCToDA,
+  ActSetTheme,
+  ActResetForm,
+  ActDSSetBool,
+  ActSubmitForm,
+  ActDSBoolToDA,
+  ActDSTextToDA,
+  ActDSCycleText,
+  ActFormErrorToDA,
+  ActSetPortalOpen,
+  ActFormStatusToDA,
+}

package/template/src/blocks/actions/form/errorToDA/block.ts

@@ -0,0 +1,18 @@
+import type { Block } from 'payload'
+import { APField } from '@/fields/apf'
+
+const ds = {
+  formName: 'The name of the front end form to use the response of.',
+  inputName: 'The name of the input to listen for changes on. If empty, defaults to using the form level message.',
+}
+
+export const ActFormErrorToDA: Block = {
+  slug: 'ActFormErrorToDA',
+  admin: { group: 'Form' },
+  interfaceName: 'ActFormErrorToDA',
+  labels: { singular: 'Form Error To Data Attribute', plural: 'Form Error To Data Attribute' },
+  fields: [
+    APField({ type: 'text', apf: ['form', 'actions'], name: 'formName', admin: { description: ds.formName }, kebab: true }),
+    APField({ type: 'text', apf: ['form', 'actions'], name: 'inputName', admin: { description: ds.inputName }, kebab: true }),
+  ],
+}

package/template/src/blocks/actions/form/errorToDA/filter.ts

@@ -0,0 +1,3 @@
+import { ActionBlockFilter } from '@/ts/types/actions'
+
+export const ActFormErrorToDA = (_: ActionBlockFilter) => true

package/template/src/blocks/actions/form/errorToDA/options.ts

@@ -0,0 +1,15 @@
+import { z } from '@/ts/zap'
+import type { ActionProcessFunction } from '@/ts/types'
+
+const processFunction: ActionProcessFunction<'ActFormErrorToDA'> = ({ formName, inputName, data, useForm, initialValuesMap }) => {
+  const key = formName || useForm
+  if (!key) throw new Error('ActFormError: formName or useForm is required')
+
+  const hasFormKey = initialValuesMap.get(key)
+  if (!hasFormKey) console.warn('ActFormError: No form found with the key:', key)
+
+  const Att: z.ap.Type<'AttFormErrorToDA'> = { type: 'AttFormErrorToDA', key, inputName }
+  data.attributers.push(Att)
+}
+
+export const ActFormErrorToDA = { processFunction }

package/template/src/blocks/actions/form/reset/block.ts

@@ -0,0 +1,18 @@
+import type { Block } from 'payload'
+import { APField } from '@/fields/apf'
+
+export const ActResetForm: Block = {
+  slug: 'ActResetForm',
+  admin: { group: 'Form' },
+  interfaceName: 'ActResetForm',
+  labels: { singular: 'Reset Form', plural: 'Reset Form' },
+  fields: [
+    APField({
+      type: 'text',
+      name: 'formName',
+      apf: ['form', 'actions'],
+      admin: { description: 'The name of the front end form to reset.' },
+      kebab: true,
+    }),
+  ],
+}

package/template/src/blocks/actions/form/reset/filter.ts

@@ -0,0 +1,3 @@
+import { ActionBlockFilter } from '@/ts/types/actions'
+
+export const ActResetForm = ({ placement, type }: ActionBlockFilter) => Boolean(placement === 'trigger' && type === 'button')

package/template/src/blocks/actions/form/reset/options.ts

@@ -0,0 +1,30 @@
+import { z } from '@/ts/zap'
+import type { ActionProcessFunction, ActionDefaultFunction } from '@/ts/types'
+
+const processFunction: ActionProcessFunction<'ActResetForm'> = ({ formName, useForm, data, initialValuesMap }) => {
+  const key = formName || useForm
+  if (!key) throw new Error('ActFormError: formName or useForm is required')
+
+  const hasFormKey = initialValuesMap.get(key)
+  if (!hasFormKey) console.warn('ActFormError: No form found with the key:', key)
+
+  const Run: z.ap.Type<'RunResetForm'> = { type: 'RunResetForm', formName: key }
+  data.runners.push(Run)
+  const Att: z.ap.Type<'AttFormStatusToDA'> = { type: 'AttFormStatusToDA', key }
+  data.attributers.push(Att)
+}
+
+const contentDefaults: ActionDefaultFunction = ({ block, data: { actions, attributers } }) => {
+  if (block.blockType === 'AtomicChild') {
+    const { formName, type } = block
+    if (!formName) return
+
+    if (type === 'form' && !actions?.includes('ActResetForm')) {
+      actions.push('ActResetForm')
+      const Att: z.ap.Type<'AttFormStatusToDA'> = { type: 'AttFormStatusToDA', key: formName }
+      attributers.push(Att)
+    }
+  }
+}
+
+export const ActResetForm = { processFunction, contentDefaults }

package/template/src/blocks/actions/form/statusToDA/block.ts

@@ -0,0 +1,12 @@
+import type { Block } from 'payload'
+import { APField } from '@/fields/apf'
+
+const description = 'The name of the front end form to check the status of.'
+
+export const ActFormStatusToDA: Block = {
+  slug: 'ActFormStatusToDA',
+  admin: { group: 'Form' },
+  interfaceName: 'ActFormStatusToDA',
+  labels: { singular: 'Form Status To DA', plural: 'Form Status To DA' },
+  fields: [APField({ type: 'text', name: 'formName', apf: ['form', 'actions'], admin: { description }, kebab: true })],
+}

package/template/src/blocks/actions/form/statusToDA/filter.ts

@@ -0,0 +1,3 @@
+import { ActionBlockFilter } from '@/ts/types/actions'
+
+export const ActFormStatusToDA = (_: ActionBlockFilter) => true

package/template/src/blocks/actions/form/statusToDA/options.ts

@@ -0,0 +1,15 @@
+import { z } from '@/ts/zap'
+import type { ActionProcessFunction } from '@/ts/types'
+
+const processFunction: ActionProcessFunction<'ActFormStatusToDA'> = ({ formName, data, useForm, initialValuesMap }) => {
+  const key = formName || useForm
+  if (!key) throw new Error('ActFormError: formName or useForm is required')
+
+  const hasFormKey = initialValuesMap.get(key)
+  if (!hasFormKey) console.warn('ActFormStatusToDA: No form found with the key:', key)
+
+  const Att: z.ap.Type<'AttFormStatusToDA'> = { type: 'AttFormStatusToDA', key }
+  data.attributers.push(Att)
+}
+
+export const ActFormStatusToDA = { processFunction }

package/template/src/blocks/actions/form/submit/block.ts

@@ -0,0 +1,18 @@
+import type { Block } from 'payload'
+import { APField } from '@/fields/apf'
+
+export const ActSubmitForm: Block = {
+  slug: 'ActSubmitForm',
+  admin: { group: 'Form' },
+  interfaceName: 'ActSubmitForm',
+  labels: { singular: 'Submit Form', plural: 'Submit Form' },
+  fields: [
+    APField({
+      type: 'text',
+      name: 'formName',
+      apf: ['form', 'actions'],
+      admin: { description: 'The name of the front end form to submit.' },
+      kebab: true,
+    }),
+  ],
+}

package/template/src/blocks/actions/form/submit/filter.ts

@@ -0,0 +1,3 @@
+import { ActionBlockFilter } from '@/ts/types/actions'
+
+export const ActSubmitForm = ({ placement, type }: ActionBlockFilter) => Boolean(placement === 'trigger' && type === 'button')

package/template/src/blocks/actions/form/submit/options.ts

@@ -0,0 +1,35 @@
+import { z } from '@/ts/zap'
+import type { ActionProcessFunction, ActionDefaultFunction, ActionSetKeyInitialByBlock } from '@/ts/types'
+
+const setKeyInitialByBlock: ActionSetKeyInitialByBlock = ({ block }) => {
+  if (block.blockType === 'AtomicChild' && block.type === 'form' && block.formName) {
+    return { key: block.formName, persisted: Boolean(block?.persisted) }
+  }
+}
+
+const processFunction: ActionProcessFunction<'ActSubmitForm'> = ({ formName, data, useForm, initialValuesMap }) => {
+  const key = formName || useForm
+  if (!key) throw new Error('ActFormError: formName or useForm is required')
+
+  const hasFormKey = initialValuesMap.get(key)
+  if (!hasFormKey) console.warn('ActSubmitForm: No form found with the key:', key)
+
+  const Run: z.ap.Type<'RunSubmitForm'> = { type: 'RunSubmitForm', formName: key }
+  data.runners.push(Run)
+  const Att: z.ap.Type<'AttFormStatusToDA'> = { type: 'AttFormStatusToDA', key }
+  data.attributers.push(Att)
+}
+
+const contentDefaults: ActionDefaultFunction = ({ block, data: { actions, attributers } }) => {
+  if (block.blockType !== 'AtomicChild') return
+  const { formName, type } = block
+  if (!formName) return
+
+  if (type === 'form' && !actions?.includes('ActSubmitForm')) {
+    actions.push('ActSubmitForm')
+    const Att: z.ap.Type<'AttFormStatusToDA'> = { type: 'AttFormStatusToDA', key: formName }
+    attributers.push(Att)
+  }
+}
+
+export const ActSubmitForm = { processFunction, contentDefaults, setKeyInitialByBlock }

package/template/src/blocks/actions/portal/set/block.ts

@@ -0,0 +1,25 @@
+import type { Block } from 'payload'
+import { SetDataField } from '@/fields/actions'
+import { APField } from '@/fields/apf'
+
+export const ActSetPortalOpen: Block = {
+  slug: 'ActSetPortalOpen',
+  admin: { group: 'Portal' },
+  interfaceName: 'ActSetPortalOpen',
+  labels: { singular: 'Set Portal Open', plural: 'Set Portal Open' },
+  fields: [
+    {
+      type: 'row',
+      fields: [
+        APField({
+          type: 'text',
+          name: 'portal',
+          apf: ['actions'],
+          admin: { description: 'The name of the portal to toggle.', width: '25%' },
+          kebab: true,
+        }),
+        SetDataField(),
+      ],
+    },
+  ],
+}

package/template/src/blocks/actions/portal/set/filter.ts

@@ -0,0 +1,3 @@
+import { ActionBlockFilter } from '@/ts/types/actions'
+
+export const ActSetPortalOpen = ({ placement, type }: ActionBlockFilter) => Boolean(placement === 'trigger' && type === 'button')

package/template/src/blocks/actions/portal/set/options.ts

@@ -0,0 +1,43 @@
+import { z } from '@/ts/zap'
+import { ActionDefaultFunction, ActionProcessFunction, ActionSetKeyInitialByBlock } from '@/ts/types/actions'
+
+const setKeyInitialByBlock: ActionSetKeyInitialByBlock = ({ block }) => {
+  if (block.blockType === 'AtomicChild' && block.buttonType === 'portal' && block.portalName) {
+    const { portalName, persisted, pops } = block
+    if (block.portalType === 'dialog') return { key: portalName, persisted, initialValue: Boolean(block.ds?.defaultOpen) }
+    return { key: portalName, persisted, initialValue: Boolean(pops?.defaultOpen) }
+  }
+}
+
+const processFunction: ActionProcessFunction<'ActSetPortalOpen'> = ({ setDA, portal, initialValuesMap, usePortal, data }) => {
+  const key = portal || usePortal
+  if (!key) throw new Error('ActFormError: formName or useForm is required')
+
+  const iv = initialValuesMap.get(key)
+  if (!iv) console.warn('ActFormError: No portal found with the key:', key)
+
+  const Run: z.ap.Type<'RunSetBool'> = { type: 'RunSetBool', key, initialValue: Boolean(iv?.initialValue), persisted: Boolean(iv?.persisted) }
+  data.runners.push(Run)
+
+  if (setDA) {
+    const Att: z.ap.Type<'AttBoolToDA'> = { type: 'AttBoolToDA', key, initialValue: Boolean(iv?.initialValue), persisted: Boolean(iv?.persisted) }
+    data.attributers.push(Att)
+  }
+}
+
+const triggerDefaults: ActionDefaultFunction = ({ block, usePortal, data }) => {
+  if (block.blockType !== 'AtomicChild') return
+  const { portalType, ds, portalName, type, buttonType, persisted, pops } = block
+  const key = portalName || usePortal
+  if (!key) return
+
+  if (type === 'button' && buttonType === 'portal' && !data.actions?.includes('ActSetPortalOpen')) {
+    data.actions.push('ActSetPortalOpen')
+    const initialValue = portalType === 'dialog' ? ds?.defaultOpen : pops?.defaultOpen
+
+    const Run: z.ap.Type<'RunSetBool'> = { type: 'RunSetBool', key, persisted: Boolean(persisted), initialValue: Boolean(initialValue) }
+    data.runners.push(Run)
+  }
+}
+
+export const ActSetPortalOpen = { setKeyInitialByBlock, processFunction, triggerDefaults }