@woodsportal/hubspot-kit 1.0.4 → 1.0.26

package/src/dev-module-config/schema/types.ts

@@ -0,0 +1,75 @@
+export type HubSpotFieldTab = 'CONTENT' | 'STYLE'
+
+export type HubSpotFieldVisibility = {
+  controlling_field?: string | null
+  controlling_field_path?: string | null
+  controlling_value_regex?: string | null
+  property?: string | null
+  operator?: 'EQUAL' | 'NOT_EQUAL' | string | null
+  access?: string | null
+}
+
+export type HubSpotFieldDefinition = {
+  id?: string
+  name: string
+  label: string
+  help_text?: string
+  inline_help_text?: string
+  required?: boolean
+  locked?: boolean
+  type: string
+  tab?: HubSpotFieldTab
+  display?: string
+  display_width?: string | null
+  expanded?: boolean
+  children?: Array<HubSpotFieldDefinition>
+  choices?: Array<{ label: string; value: string } | [string, string]>
+  default?: unknown
+  visibility?: HubSpotFieldVisibility
+  occurrence?: {
+    min?: number | null
+    max?: number | null
+    default?: number | null
+  }
+  group_occurrence_meta?: unknown
+}
+
+/** Nested module field values keyed like HubSpot `module.*` paths */
+export type ModuleFieldValues = Record<string, unknown>
+
+export const MODULE_CONFIG_CHANGED = 'woodsportal:module-config-changed'
+
+export const HUBSPOT_ONLY_FIELD_NAMES = new Set([
+  'portal_cdn_base_url',
+  'portal_build_id',
+  'portal_vendor_script',
+  'portal_app_script',
+  'portal_app_css',
+  'hubspot_data_source',
+])
+
+/** HubSpot stores these as booleans but renders them as group expand/collapse in the native editor. */
+export const MODULE_CONFIG_UI_HIDDEN_FIELD_NAMES = new Set([
+  'developer_option',
+  'backend_server_url',
+])
+
+/** Top-level HubSpot sections that should start collapsed in the dev module config UI. */
+export const MODULE_CONFIG_DEFAULT_COLLAPSED_SECTION_NAMES = new Set([
+  'home',
+  'menu_options',
+  'other_options',
+  'sso_buttons_customize_options',
+])
+
+export function isModuleConfigSectionDefaultCollapsed(fieldName: string): boolean {
+  return MODULE_CONFIG_DEFAULT_COLLAPSED_SECTION_NAMES.has(fieldName)
+}
+
+/** Shown on Content tab only — fields without `tab` in fields.json would otherwise appear on Styles too. */
+export const MODULE_CONFIG_CONTENT_TAB_FIELD_NAMES = new Set([
+  'add_home_tab',
+  'developerMode',
+  'developer_options',
+  'home',
+])

package/src/dev-module-config/schema/validate-module-config.ts

@@ -0,0 +1,81 @@
+import { isFieldVisible, type VisibilityContext } from '../schema/visibility'
+import { getNestedValue } from '../runtime/module-config-runtime'
+import type { HubSpotFieldDefinition, ModuleFieldValues } from '../schema/types'
+
+export type ValidationError = {
+  path: string
+  label: string
+  message: string
+}
+
+function isEmptyValue(value: unknown): boolean {
+  if (value === null || value === undefined) return true
+  if (typeof value === 'string') return value.trim().length === 0
+  if (typeof value === 'boolean' || typeof value === 'number') return false
+  if (Array.isArray(value)) return value.length === 0
+  if (typeof value === 'object') {
+    const record = value as Record<string, unknown>
+    if ('src' in record) return !String(record.src ?? '').trim()
+    if ('url' in record) {
+      const url = record.url as { href?: string } | undefined
+      return !String(url?.href ?? '').trim()
+    }
+    if ('color' in record) return !String(record.color ?? '').trim()
+    return Object.keys(record).length === 0
+  }
+  return false
+}
+
+function validateFieldsAtPath(
+  fields: Array<HubSpotFieldDefinition>,
+  moduleValues: ModuleFieldValues,
+  pathPrefix: string,
+  context: VisibilityContext,
+  errors: Array<ValidationError>,
+): void {
+  for (const field of fields) {
+    if (!isFieldVisible(field, context)) continue
+
+    const path = pathPrefix ? `${pathPrefix}.${field.name}` : field.name
+    const value = getNestedValue(moduleValues, path)
+
+    if (field.required && isEmptyValue(value)) {
+      errors.push({
+        path,
+        label: field.label,
+        message: `${field.label} is required`,
+      })
+    }
+
+    if (field.type === 'group' && field.children?.length) {
+      if (field.occurrence && Array.isArray(value)) {
+        value.forEach((item, index) => {
+          const itemPath = `${path}.${index}`
+          validateFieldsAtPath(field.children ?? [], moduleValues, itemPath, {
+            ...context,
+            repeaterPath: path,
+            itemIndex: index,
+            itemValues: item as ModuleFieldValues,
+          }, errors)
+        })
+      } else if (!field.occurrence) {
+        validateFieldsAtPath(field.children, moduleValues, path, context, errors)
+      }
+    }
+  }
+}
+
+export function validateModuleConfig(
+  schema: Array<HubSpotFieldDefinition>,
+  moduleValues: ModuleFieldValues,
+): Array<ValidationError> {
+  const errors: Array<ValidationError> = []
+  validateFieldsAtPath(schema, moduleValues, '', { moduleValues }, errors)
+
+  const seen = new Set<string>()
+  return errors.filter((error) => {
+    if (seen.has(error.path)) return false
+    seen.add(error.path)
+    return true
+  })
+}

package/src/dev-module-config/schema/visibility.ts

@@ -0,0 +1,130 @@
+import type { HubSpotFieldDefinition, ModuleFieldValues } from './types'
+
+export type VisibilityContext = {
+  /** Full module values */
+  moduleValues: ModuleFieldValues
+  /** e.g. menu_options.objects */
+  repeaterPath?: string
+  /** Index within repeater array */
+  itemIndex?: number
+  /** Current item values when editing a repeater row */
+  itemValues?: ModuleFieldValues
+}
+
+function getByPath(obj: ModuleFieldValues, path: string): unknown {
+  const parts = path.split('.')
+  let current: unknown = obj
+  for (const part of parts) {
+    if (current === null || current === undefined || typeof current !== 'object') {
+      return undefined
+    }
+    if (/^\d+$/.test(part)) {
+      current = (current as Array<unknown>)[Number(part)]
+    } else {
+      current = (current as Record<string, unknown>)[part]
+    }
+  }
+  return current
+}
+
+function resolveControlValue(
+  controllingPath: string,
+  context: VisibilityContext,
+): unknown {
+  const { moduleValues, repeaterPath, itemIndex, itemValues } = context
+
+  if (repeaterPath && itemValues && controllingPath.startsWith(`${repeaterPath}.`)) {
+    const relative = controllingPath.slice(repeaterPath.length + 1)
+    const topKey = relative.split('.')[0]
+    if (topKey in itemValues) {
+      return getByPath(itemValues, relative)
+    }
+  }
+
+  if (repeaterPath && itemIndex !== undefined && controllingPath.startsWith(`${repeaterPath}.`)) {
+    const relative = controllingPath.slice(repeaterPath.length + 1)
+    const list = getByPath(moduleValues, repeaterPath)
+    if (Array.isArray(list) && list[itemIndex]) {
+      return getByPath(list[itemIndex] as ModuleFieldValues, relative)
+    }
+  }
+
+  return getByPath(moduleValues, controllingPath)
+}
+
+function regexMatches(value: unknown, regex: string): boolean {
+  if (regex === 'true') return value === true || value === 'true'
+  if (regex === 'false') return value === false || value === 'false'
+  try {
+    return new RegExp(regex).test(String(value ?? ''))
+  } catch {
+    return String(value ?? '') === regex
+  }
+}
+
+function isVisibilityContext(
+  value: ModuleFieldValues | VisibilityContext,
+): value is VisibilityContext {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'moduleValues' in value &&
+    typeof (value as VisibilityContext).moduleValues === 'object'
+  )
+}
+
+export function isFieldVisible(
+  field: HubSpotFieldDefinition,
+  moduleValuesOrContext: ModuleFieldValues | VisibilityContext,
+): boolean {
+  const context: VisibilityContext = isVisibilityContext(moduleValuesOrContext)
+    ? moduleValuesOrContext
+    : { moduleValues: moduleValuesOrContext }
+
+  const visibility = field.visibility
+  if (!visibility?.controlling_field_path) return true
+
+  const controlValue = resolveControlValue(visibility.controlling_field_path, context)
+  const regex = visibility.controlling_value_regex ?? 'true'
+
+  // HubSpot-only field hidden locally — treat as false so CRM-specific fields stay hidden.
+  if (
+    visibility.controlling_field_path === 'hubspot_data_source' &&
+    (controlValue === undefined || controlValue === null || controlValue === '')
+  ) {
+    const matchesFalse = regexMatches(false, regex)
+    if (visibility.operator === 'NOT_EQUAL') return !matchesFalse
+    return matchesFalse
+  }
+
+  const matches = regexMatches(controlValue, regex)
+
+  if (visibility.operator === 'NOT_EQUAL') return !matches
+  return matches
+}
+
+export function flattenVisibleFields(
+  fields: Array<HubSpotFieldDefinition>,
+  moduleValues: ModuleFieldValues,
+  tab?: 'CONTENT' | 'STYLE',
+  context?: Omit<VisibilityContext, 'moduleValues'>,
+): Array<HubSpotFieldDefinition> {
+  const result: Array<HubSpotFieldDefinition> = []
+  const visibilityContext: VisibilityContext = { moduleValues, ...context }
+
+  for (const field of fields) {
+    if (tab && field.tab && field.tab !== tab) continue
+    if (!isFieldVisible(field, visibilityContext)) continue
+    result.push(field)
+  }
+
+  return result
+}
+
+export function chunkFields<T>(items: Array<T>, size: number): Array<Array<T>> {
+  const pages: Array<Array<T>> = []
+  for (let i = 0; i < items.length; i += size) {
+    pages.push(items.slice(i, i + size))
+  }
+  return pages.length ? pages : [[]]
+}

package/src/dev-module-config/storage/config-json.ts

@@ -0,0 +1,46 @@
+import type { ModuleFieldValues } from '../schema/types'
+
+export type WorkspaceConfigRecord = {
+  version: number
+  module: ModuleFieldValues
+  updatedAt: string | null
+  source?: 'local' | 'example' | 'empty'
+}
+
+export function exportConfigJson(moduleValues: ModuleFieldValues): string {
+  return JSON.stringify({ version: 1, module: moduleValues }, null, 2)
+}
+
+export function importConfigJson(raw: string): ModuleFieldValues {
+  const parsed = JSON.parse(raw) as { module?: ModuleFieldValues } | ModuleFieldValues
+  if ('module' in parsed && parsed.module && typeof parsed.module === 'object') {
+    return parsed.module as ModuleFieldValues
+  }
+  if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+    return parsed as ModuleFieldValues
+  }
+  throw new Error('Invalid module config JSON')
+}
+
+export async function uploadBrandingAsset(file: File): Promise<string> {
+  const buffer = await file.arrayBuffer()
+  const bytes = new Uint8Array(buffer)
+  let binary = ''
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]!)
+  }
+  const data = btoa(binary)
+
+  const response = await fetch('/__dev/branding-asset', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ filename: file.name, data }),
+  })
+
+  if (!response.ok) {
+    throw new Error(`Upload failed: ${response.status}`)
+  }
+
+  const payload = (await response.json()) as { src: string }
+  return payload.src
+}

package/src/dev-module-config/storage/workspace-store.ts

@@ -0,0 +1,139 @@
+import { deepMerge } from '../schema/deep-merge'
+import type { ModuleFieldValues } from '../schema/types'
+import type { WorkspaceConfigRecord } from './config-json'
+
+const DB_NAME = 'woodsportal-module-config'
+const DB_VERSION = 1
+const OVERRIDES_KEY = 'active'
+
+type OverridesRecord = {
+  version: number
+  patches: ModuleFieldValues
+  updatedAt: string
+}
+
+export { exportConfigJson, importConfigJson, uploadBrandingAsset } from './config-json'
+
+export async function loadWorkspaceMeta(): Promise<WorkspaceConfigRecord['source']> {
+  try {
+    const response = await fetch('/__dev/module-config')
+    if (!response.ok) return 'empty'
+    const record = (await response.json()) as WorkspaceConfigRecord
+    return record.source ?? 'empty'
+  } catch {
+    return 'empty'
+  }
+}
+
+export async function loadOverrides(): Promise<ModuleFieldValues> {
+  try {
+    const migrated = await migrateFromIndexedDbIfNeeded()
+    if (migrated) return migrated
+
+    const response = await fetch('/__dev/module-config')
+    if (!response.ok) return {}
+    const record = (await response.json()) as WorkspaceConfigRecord
+    return record.module ?? {}
+  } catch {
+    return {}
+  }
+}
+
+export async function saveOverrides(patches: ModuleFieldValues): Promise<void> {
+  const record: WorkspaceConfigRecord = {
+    version: 1,
+    module: patches,
+    updatedAt: new Date().toISOString(),
+    source: 'local',
+  }
+
+  const response = await fetch('/__dev/module-config', {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(record),
+  })
+
+  if (!response.ok) {
+    throw new Error(`Failed to save module config: ${response.status}`)
+  }
+}
+
+export async function clearOverrides(): Promise<void> {
+  const response = await fetch('/__dev/module-config', { method: 'DELETE' })
+  if (!response.ok && response.status !== 204) {
+    throw new Error(`Failed to clear module config: ${response.status}`)
+  }
+}
+
+export async function mergeWithDefaults(
+  defaults: ModuleFieldValues,
+  patches: ModuleFieldValues,
+): Promise<ModuleFieldValues> {
+  return deepMerge(defaults, patches)
+}
+
+async function migrateFromIndexedDbIfNeeded(): Promise<ModuleFieldValues | null> {
+  if (typeof indexedDB === 'undefined') return null
+
+  try {
+    const response = await fetch('/__dev/module-config')
+    if (!response.ok) return null
+    const record = (await response.json()) as WorkspaceConfigRecord
+    if (record.source === 'local') return null
+
+    const idbPatches = await readIndexedDbOverrides()
+    if (!idbPatches || Object.keys(idbPatches).length === 0) return null
+
+    await saveOverrides(idbPatches)
+    await clearIndexedDbOverrides()
+    console.info('[module-config] migrated IndexedDB overrides → .dev/module-config.local.json')
+    return idbPatches
+  } catch {
+    return null
+  }
+}
+
+function openDb(): Promise<IDBDatabase> {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(DB_NAME, DB_VERSION)
+    request.onerror = () => reject(request.error ?? new Error('IndexedDB open failed'))
+    request.onsuccess = () => resolve(request.result)
+    request.onupgradeneeded = () => {
+      const db = request.result
+      if (!db.objectStoreNames.contains('overrides')) {
+        db.createObjectStore('overrides')
+      }
+    }
+  })
+}
+
+async function readIndexedDbOverrides(): Promise<ModuleFieldValues | null> {
+  try {
+    const db = await openDb()
+    return await new Promise((resolve, reject) => {
+      const tx = db.transaction('overrides', 'readonly')
+      const request = tx.objectStore('overrides').get(OVERRIDES_KEY)
+      request.onerror = () => reject(request.error)
+      request.onsuccess = () => {
+        const record = request.result as OverridesRecord | undefined
+        resolve(record?.patches ?? null)
+      }
+    })
+  } catch {
+    return null
+  }
+}
+
+async function clearIndexedDbOverrides(): Promise<void> {
+  try {
+    const db = await openDb()
+    await new Promise<void>((resolve, reject) => {
+      const tx = db.transaction('overrides', 'readwrite')
+      const request = tx.objectStore('overrides').delete(OVERRIDES_KEY)
+      request.onerror = () => reject(request.error)
+      request.onsuccess = () => resolve()
+    })
+  } catch {
+    // ignore migration cleanup errors
+  }
+}