@spacemade/ui 0.0.1

package/scripts/crud-scaffold/src/app/patches.mjs

@@ -0,0 +1,355 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import {
+  addOptionalTypeField,
+  addUnionValue,
+  escapeRegExp,
+  integrationKey,
+  markerBlock,
+  markerName,
+  pageRoute,
+  removeMarkedBlock,
+  removeUnionValue,
+  replaceMarkedBlock,
+  writeIfChanged,
+} from '../core/utils.mjs'
+import { quote } from '../core/fields.mjs'
+
+function createGeneratedSideNavItem(resources, options) {
+  const nav = options.sideNav
+  const activeResources = Array.isArray(nav.activeRoutes)
+    ? resources.filter((resource) => nav.activeRoutes.includes(resource.route) || nav.activeRoutes.includes(resource.name))
+    : resources
+  const hrefs = activeResources.map((resource) => `/${pageRoute(resource, options)}`)
+  const primaryHref = nav.href || `/${pageRoute(
+    resources.find((resource) => resource.route === nav.primaryRoute || resource.name === nav.primaryResource) || resources[0],
+    options
+  )}`
+  const activeHrefs = hrefs.map(quote).join(', ')
+
+  return markerBlock(
+    '  ',
+    markerName(nav.appKey, 'nav-item'),
+    `  { label: '${nav.label}', icon: <i className="${nav.icon}" />, title: '${nav.title}', href: '${primaryHref}', activeHrefs: [${activeHrefs}] },`
+  )
+}
+
+function createAdditionalSideNavItem(resources, options, item) {
+  const target = item.route || item.primaryRoute || item.resource
+  const resource = resources.find((entry) => entry.route === target || entry.name === target)
+  const href = item.href || (resource ? `/${pageRoute(resource, options)}` : '')
+  const activeRoutes = Array.isArray(item.activeRoutes) ? item.activeRoutes : target ? [target] : []
+  const activeHrefs = activeRoutes
+    .map((route) => {
+      const activeResource = resources.find((entry) => entry.route === route || entry.name === route)
+      return activeResource ? `/${pageRoute(activeResource, options)}` : route
+    })
+    .map(quote)
+    .join(', ')
+  const markerKey = item.key || item.appKey || item.label.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
+
+  return markerBlock(
+    '  ',
+    markerName(markerKey, 'nav-item'),
+    `  { label: '${item.label}', icon: <i className="${item.icon}" />, title: '${item.title || item.label}', href: '${href}', activeHrefs: [${activeHrefs || quote(href)}] },`
+  )
+}
+
+function createGeneratedSideNavMap(resources, options) {
+  const nav = options.sideNav
+  const activeResources = Array.isArray(nav.activeRoutes)
+    ? resources.filter((resource) => nav.activeRoutes.includes(resource.route) || nav.activeRoutes.includes(resource.name))
+    : resources
+
+  return markerBlock(
+    '    ',
+    markerName(nav.appKey, 'nav-map'),
+    activeResources
+      .map((resource) => `    '/${pageRoute(resource, options)}': '${nav.appKey}',`)
+      .join('\n')
+  )
+}
+
+function createAdditionalSideNavMap(resources, options, item) {
+  const target = item.route || item.primaryRoute || item.resource
+  const routes = Array.isArray(item.activeRoutes) ? item.activeRoutes : target ? [target] : []
+  const markerKey = item.key || item.appKey || item.label.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
+  const appKey = item.permissionAppKey || options.sideNav.appKey
+
+  return markerBlock(
+    '    ',
+    markerName(markerKey, 'nav-map'),
+    routes
+      .map((route) => {
+        const resource = resources.find((entry) => entry.route === route || entry.name === route)
+        return resource ? `    '/${pageRoute(resource, options)}': '${appKey}',` : `    '${route}': '${appKey}',`
+      })
+      .join('\n')
+  )
+}
+
+function insertGeneratedSideNavItem(source, navItem, options) {
+  if (options.sideNav.insertBeforeHref) {
+    const navItemAnchor = new RegExp(
+      `(\\s*\\{[^\\n]*href: '${escapeRegExp(options.sideNav.insertBeforeHref)}'[^\\n]*\\},\\n)`
+    )
+
+    return source.replace(navItemAnchor, `${navItem}\n$1`)
+  }
+
+  if (options.sideNav.insertAfterHref) {
+    const navItemAnchor = new RegExp(
+      `(\\s*\\{[^\\n]*href: '${escapeRegExp(options.sideNav.insertAfterHref)}'[^\\n]*\\},\\n)`
+    )
+
+    return source.replace(navItemAnchor, `$1${navItem}\n`)
+  }
+
+  const generatedItemPattern =
+    /\n\s*\/\/ <[a-zA-Z0-9_-]+-generated-nav-item>[\s\S]*?\/\/ <\/[a-zA-Z0-9_-]+-generated-nav-item>\n?/g
+  const generatedItems = Array.from(source.matchAll(generatedItemPattern))
+  const lastGeneratedItem = generatedItems.at(-1)
+
+  if (lastGeneratedItem?.index !== undefined) {
+    const insertAt = lastGeneratedItem.index + lastGeneratedItem[0].length
+    return `${source.slice(0, insertAt)}${navItem}\n${source.slice(insertAt)}`
+  }
+
+  return source.replace(
+    /(const DEFAULT_ITEMS: NavItem\[] = \[\n)/,
+    `$1${navItem}\n`
+  )
+}
+
+function insertGeneratedSideNavMap(source, navMap, options) {
+  if (options.sideNav.insertAfterHref) {
+    const navMapAnchor = new RegExp(
+      `(\\s*'${escapeRegExp(options.sideNav.insertAfterHref)}': '[^']+',\\n)`
+    )
+
+    return source.replace(navMapAnchor, `$1${navMap}\n`)
+  }
+
+  const generatedMapPattern =
+    /\n\s*\/\/ <[a-zA-Z0-9_-]+-generated-nav-map>[\s\S]*?\/\/ <\/[a-zA-Z0-9_-]+-generated-nav-map>\n?/g
+  const generatedMaps = Array.from(source.matchAll(generatedMapPattern))
+  const lastGeneratedMap = generatedMaps.at(-1)
+
+  if (lastGeneratedMap?.index !== undefined) {
+    const insertAt = lastGeneratedMap.index + lastGeneratedMap[0].length
+    return `${source.slice(0, insertAt)}${navMap}\n${source.slice(insertAt)}`
+  }
+
+  return source.replace(
+    /(const NAV_APP_MAP: Record<string, NavAppKey> = \{\n)/,
+    `$1${navMap}\n`
+  )
+}
+
+export function patchSideNavLayout(root, resources, options) {
+  if (!options.sideNav) return
+
+  const filePath = path.join(root, options.sideNav.layoutPath || 'src/components/common/layout/SideNavLayout.tsx')
+  let source = fs.readFileSync(filePath, 'utf8')
+
+  ;(options.sideNav.previousAppKeys || []).forEach((appKey) => {
+    source = removeMarkedBlock(source, markerName(appKey, 'nav-item'))
+    source = removeMarkedBlock(source, markerName(appKey, 'nav-map'))
+    source = removeUnionValue(source, 'NavAppKey', appKey)
+  })
+
+  ;(options.sideNav.previousAdditionalItemKeys || []).forEach((key) => {
+    source = removeMarkedBlock(source, markerName(key, 'nav-item'))
+    source = removeMarkedBlock(source, markerName(key, 'nav-map'))
+  })
+
+  source = addOptionalTypeField(source, 'NavItem', 'activeHrefs?: string[]')
+  source = addUnionValue(source, 'NavAppKey', options.sideNav.appKey)
+
+  const navItem = createGeneratedSideNavItem(resources, options)
+  const navItemMarker = markerName(options.sideNav.appKey, 'nav-item')
+  if (source.includes(`// <${navItemMarker}>`)) {
+    source = replaceMarkedBlock(source, navItemMarker, navItem)
+  } else {
+    source = insertGeneratedSideNavItem(source, navItem, options)
+  }
+
+  const navMap = createGeneratedSideNavMap(resources, options)
+  const navMapMarker = markerName(options.sideNav.appKey, 'nav-map')
+  if (source.includes(`// <${navMapMarker}>`)) {
+    source = replaceMarkedBlock(source, navMapMarker, navMap)
+  } else {
+    source = insertGeneratedSideNavMap(source, navMap, options)
+  }
+
+  ;(options.sideNav.additionalItems || []).forEach((item) => {
+    const markerKey = item.key || item.appKey || item.label.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
+    const additionalNavItem = createAdditionalSideNavItem(resources, options, item)
+    const additionalNavItemMarker = markerName(markerKey, 'nav-item')
+    if (source.includes(`// <${additionalNavItemMarker}>`)) {
+      source = replaceMarkedBlock(source, additionalNavItemMarker, additionalNavItem)
+    } else {
+      source = insertGeneratedSideNavItem(source, additionalNavItem, options)
+    }
+
+    const additionalNavMap = createAdditionalSideNavMap(resources, options, item)
+    const additionalNavMapMarker = markerName(markerKey, 'nav-map')
+    if (source.includes(`// <${additionalNavMapMarker}>`)) {
+      source = replaceMarkedBlock(source, additionalNavMapMarker, additionalNavMap)
+    } else {
+      source = insertGeneratedSideNavMap(source, additionalNavMap, options)
+    }
+  })
+
+  if (!source.includes('const activeHrefs = item.activeHrefs || [href]')) {
+    source = source.replace(
+      `    const normalizedHref = href === '/' ? '/' : href.replace(/\\/+$/, '')
+    if (normalizedHref === '/') return currentPath === '/'
+    return currentPath === normalizedHref || currentPath.startsWith(\`\${normalizedHref}/\`)`,
+      `    const activeHrefs = item.activeHrefs || [href]
+    return activeHrefs.some((activeHref) => {
+      const normalizedHref = activeHref === '/' ? '/' : activeHref.replace(/\\/+$/, '')
+      if (normalizedHref === '/') return currentPath === '/'
+      return currentPath === normalizedHref || currentPath.startsWith(\`\${normalizedHref}/\`)
+    })`
+    )
+  }
+
+  if (writeIfChanged(filePath, source)) {
+    console.log(`update ${path.relative(root, filePath)}`)
+  }
+}
+
+function createGeneratedPermissionDef(options) {
+  const permission = options.permissions
+  const actions = permission.actions.map(quote).join(', ')
+
+  return markerBlock(
+    '  ',
+    markerName(permission.appKey, 'permission-def'),
+    `  {
+    key: '${permission.appKey}',
+    label: '${permission.label}',
+    actions: [${actions}],
+  },`
+  )
+}
+
+export function patchPermissionDefinitions(root, options) {
+  if (!options.permissions) return
+
+  const filePath = path.join(root, options.permissions.path || 'src/helpers/permissions/index.ts')
+  let source = fs.readFileSync(filePath, 'utf8')
+
+  ;(options.permissions.previousAppKeys || []).forEach((appKey) => {
+    source = removeMarkedBlock(source, markerName(appKey, 'permission-def'))
+    source = removeUnionValue(source, 'AppKey', appKey)
+  })
+
+  source = addUnionValue(source, 'AppKey', options.permissions.appKey)
+
+  const permissionDef = createGeneratedPermissionDef(options)
+  const permissionMarker = markerName(options.permissions.appKey, 'permission-def')
+  if (source.includes(`// <${permissionMarker}>`)) {
+    source = replaceMarkedBlock(source, permissionMarker, permissionDef)
+  } else {
+    const insertAfterAppKey = options.permissions.insertAfterAppKey || 'providers'
+    const permissionAnchor = new RegExp(
+      `(\\s*\\{\\n\\s*key: '${escapeRegExp(insertAfterAppKey)}',[\\s\\S]*?\\n\\s*\\},\\n)`
+    )
+    source = source.replace(
+      permissionAnchor,
+      `$1${permissionDef}\n`
+    )
+  }
+
+  if (writeIfChanged(filePath, source)) {
+    console.log(`update ${path.relative(root, filePath)}`)
+  }
+}
+
+function createGeneratedStoreImport(options) {
+  const store = options.store
+  const importPath =
+    store.importPath ||
+    `${options.src.importRoot}/store/slice/api/${store.apiSliceName}`
+
+  return markerBlock(
+    '',
+    markerName(integrationKey(options), 'store-import'),
+    `import { ${store.apiSliceName} } from '${importPath}'`
+  )
+}
+
+function createGeneratedStoreReducer(options) {
+  const apiSliceName = options.store.apiSliceName
+
+  return markerBlock(
+    '\t\t\t',
+    markerName(integrationKey(options), 'store-reducer'),
+    `\t\t\t[${apiSliceName}.reducerPath]: ${apiSliceName}.reducer,`
+  )
+}
+
+function createGeneratedStoreMiddleware(options) {
+  const apiSliceName = options.store.apiSliceName
+
+  return markerBlock(
+    '\t\t\t\t',
+    markerName(integrationKey(options), 'store-middleware'),
+    `\t\t\t\t${apiSliceName}.middleware,`
+  )
+}
+
+export function patchStore(root, options) {
+  if (!options.store?.apiSliceName) return
+
+  const filePath = path.join(root, options.store.path || 'src/store/store.ts')
+  let source = fs.readFileSync(filePath, 'utf8')
+  const key = integrationKey(options)
+
+  const importBlock = createGeneratedStoreImport(options)
+  const importMarker = markerName(key, 'store-import')
+  if (source.includes(`// <${importMarker}>`)) {
+    source = replaceMarkedBlock(source, importMarker, importBlock)
+  } else {
+    source = source.replace(
+      /(\nexport const makeStore = \(\) =>)/,
+      `\n${importBlock}\n$1`
+    )
+  }
+
+  const reducerBlock = createGeneratedStoreReducer(options)
+  const reducerMarker = markerName(key, 'store-reducer')
+  if (source.includes(`// <${reducerMarker}>`)) {
+    source = replaceMarkedBlock(source, reducerMarker, reducerBlock)
+  } else {
+    const insertAfterApiSlice = options.store.insertAfterApiSlice || 'pageApiSlice'
+    const reducerAnchor = new RegExp(
+      `(\\n\\t\\t\\t\\[${escapeRegExp(insertAfterApiSlice)}\\.reducerPath\\]: ${escapeRegExp(insertAfterApiSlice)}\\.reducer,\\n)`
+    )
+    source = source.replace(
+      reducerAnchor,
+      `$1${reducerBlock}\n`
+    )
+  }
+
+  const middlewareBlock = createGeneratedStoreMiddleware(options)
+  const middlewareMarker = markerName(key, 'store-middleware')
+  if (source.includes(`// <${middlewareMarker}>`)) {
+    source = replaceMarkedBlock(source, middlewareMarker, middlewareBlock)
+  } else {
+    const insertAfterApiSlice = options.store.insertAfterApiSlice || 'pageApiSlice'
+    const middlewareAnchor = new RegExp(
+      `(\\n\\t\\t\\t\\t${escapeRegExp(insertAfterApiSlice)}\\.middleware,\\n)`
+    )
+    source = source.replace(
+      middlewareAnchor,
+      `$1${middlewareBlock}\n`
+    )
+  }
+
+  if (writeIfChanged(filePath, source)) {
+    console.log(`update ${path.relative(root, filePath)}`)
+  }
+}

package/scripts/crud-scaffold/src/core/fields.mjs

@@ -0,0 +1,165 @@
+export const quote = (value) => `'${value}'`
+
+export function tsUnion(values) {
+  return values.map(quote).join(' | ')
+}
+
+export function enumDataType(values) {
+  return `DataTypes.ENUM(${values.map(quote).join(', ')})`
+}
+
+function schema(config = {}) {
+  const parts = [`type: '${config.type}'`]
+
+  if (config.required) parts.push('isRequired: true')
+  if (config.nullable) parts.push('allowNull: true')
+  if (config.minLength) parts.push(`minLength: ${config.minLength}`)
+  if (config.maxLength) parts.push(`maxLength: ${config.maxLength}`)
+  if (config.regex) parts.push(`regex: ${config.regex}`)
+  if (config.enum) parts.push(`enum: [${config.enum.map(quote).join(', ')}]`)
+
+  return `{ ${parts.join(', ')} }`
+}
+
+export const field = {
+  string(name, options = {}) {
+    return {
+      name,
+      tsType: options.nullable ? 'string | null' : 'string',
+      dataType: 'DataTypes.STRING',
+      allowNull: !!options.nullable,
+      defaultValue: options.defaultValue,
+      references: options.references,
+      onDelete: options.onDelete,
+      validate: options.validate,
+      skipSchema: !!options.skipSchema,
+      hideInTable: !!options.hideInTable,
+      schema: schema({
+        type: 'string',
+        required: options.required,
+        nullable: options.nullable,
+        minLength: options.minLength,
+        maxLength: options.maxLength,
+        regex: options.regex,
+      }),
+    }
+  },
+
+  text(name, options = {}) {
+    return {
+      name,
+      tsType: options.nullable ? 'string | null' : 'string',
+      dataType: "DataTypes.TEXT('medium')",
+      allowNull: !!options.nullable,
+      defaultValue: options.defaultValue,
+      skipSchema: !!options.skipSchema,
+      hideInTable: !!options.hideInTable,
+      schema: schema({
+        type: 'string',
+        required: options.required,
+        nullable: options.nullable,
+      }),
+    }
+  },
+
+  boolean(name, options = {}) {
+    return {
+      name,
+      tsType: 'boolean',
+      dataType: 'DataTypes.BOOLEAN',
+      allowNull: !!options.nullable,
+      defaultValue: options.defaultValue,
+      skipSchema: !!options.skipSchema,
+      hideInTable: !!options.hideInTable,
+      schema: schema({
+        type: 'boolean',
+        required: options.required,
+        nullable: options.nullable,
+      }),
+    }
+  },
+
+  number(name, options = {}) {
+    return {
+      name,
+      tsType: options.nullable ? 'number | null' : 'number',
+      dataType: options.integer ? 'DataTypes.INTEGER' : 'DataTypes.DECIMAL(10, 2)',
+      allowNull: !!options.nullable,
+      defaultValue: options.defaultValue,
+      skipSchema: !!options.skipSchema,
+      hideInTable: !!options.hideInTable,
+      schema: schema({
+        type: 'number',
+        required: options.required,
+        nullable: options.nullable,
+      }),
+    }
+  },
+
+  uuid(name, options = {}) {
+    return {
+      name,
+      tsType: options.nullable ? 'string | null' : 'string',
+      dataType: 'DataTypes.UUID',
+      allowNull: !!options.nullable,
+      references: options.references,
+      onDelete: options.onDelete,
+      validate: options.validate,
+      skipSchema: !!options.skipSchema,
+      hideInTable: !!options.hideInTable,
+      schema: schema({
+        type: 'string',
+        required: options.required,
+        nullable: options.nullable,
+      }),
+    }
+  },
+
+  enum(name, values, options = {}) {
+    return {
+      name,
+      tsType: tsUnion(values),
+      dataType: enumDataType(values),
+      enumValues: values,
+      allowNull: !!options.nullable,
+      defaultValue: options.defaultValue,
+      skipSchema: !!options.skipSchema,
+      hideInTable: !!options.hideInTable,
+      schema: schema({
+        type: 'string',
+        required: options.required,
+        nullable: options.nullable,
+        enum: values,
+      }),
+    }
+  },
+
+  date(name, options = {}) {
+    return {
+      name,
+      tsType: options.nullable ? 'Date | null' : 'Date',
+      dataType: 'DataTypes.DATE',
+      allowNull: !!options.nullable,
+      skipSchema: !!options.skipSchema,
+      hideInTable: !!options.hideInTable,
+      schema: schema({
+        type: 'string',
+        required: options.required,
+        nullable: options.nullable,
+      }),
+    }
+  },
+
+  json(name, options = {}) {
+    return {
+      name,
+      tsType: options.nullable ? 'Record<string, unknown> | null' : 'Record<string, unknown>',
+      dataType: 'DataTypes.JSON',
+      allowNull: !!options.nullable,
+      isJson: true,
+      skipSchema: true,
+      hideInTable: !!options.hideInTable,
+    }
+  },
+}
+

package/scripts/crud-scaffold/src/core/utils.mjs

@@ -0,0 +1,161 @@
+import fs from 'node:fs'
+import { quote } from './fields.mjs'
+
+export const tableName = (resource) => resource.tableName || resource.slug.replaceAll('-', '_')
+
+export const pascalFromRoute = (route) =>
+  route
+    .split('-')
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join('')
+
+export const camel = (value) => value.charAt(0).toLowerCase() + value.slice(1)
+
+export const snakeToCamel = (value) =>
+  value.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase())
+
+export const titleize = (value) =>
+  value
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .replace(/[_-]+/g, ' ')
+    .replace(/\b\w/g, (letter) => letter.toUpperCase())
+
+export const pageRoute = (resource, options) =>
+  resource.route.replace(new RegExp(`^${options.routePrefix || ''}`), '')
+
+export const markerBlock = (indent, name, contents) => `${indent}// <${name}>
+${contents}
+${indent}// </${name}>`
+
+export const markerName = (appKey, name) =>
+  `${String(appKey).replace(/[^a-zA-Z0-9_-]/g, '-')}-generated-${name}`
+
+export const escapeRegExp = (value) => String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+export const integrationKey = (options) =>
+  options.store?.integrationKey ||
+  options.sideNav?.appKey ||
+  options.permissions?.appKey ||
+  options.store?.apiSliceName ||
+  options.title?.toLowerCase().replace(/[^a-zA-Z0-9_-]/g, '-')
+
+export const namespace = (options) => {
+  const key = integrationKey(options)
+  const kebab = options.namespace?.kebab || String(key).replace(/[^a-zA-Z0-9_-]/g, '-')
+  const camelName = options.namespace?.camel || camel(kebab.split('-').map((part, index) =>
+    index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)
+  ).join(''))
+  const pascalName = options.namespace?.pascal || camelName.charAt(0).toUpperCase() + camelName.slice(1)
+  const title = options.namespace?.title || options.title || pascalName
+
+  return {
+    camel: camelName,
+    kebab,
+    pascal: pascalName,
+    title,
+    resourcesFile: `${kebab}-resources`,
+    modelFile: `${kebab}.model`,
+  }
+}
+
+const resourceFieldNames = (resource) => new Set(resource.fields.map((item) => item.name))
+
+function normalizeScopeOption(value, defaultField) {
+  if (!value) return null
+  if (value === true) return { field: defaultField }
+  if (typeof value === 'string') return { field: value }
+  if (typeof value === 'object') return { field: value.field || defaultField, ...value }
+  return null
+}
+
+export function getResourceScope(resource, options) {
+  const fields = resourceFieldNames(resource)
+  const configured = {
+    ...(options.scope || {}),
+    ...(resource.scope || {}),
+  }
+  const org = normalizeScopeOption(configured.org ?? configured.orgField, 'org_id')
+  const project = normalizeScopeOption(configured.project ?? configured.projectField, 'project_id')
+  const orgField = org?.field && fields.has(org.field) ? org.field : null
+  const projectField = project?.field && fields.has(project.field) ? project.field : null
+
+  return {
+    orgField,
+    projectField,
+    resource:
+      configured.resource ||
+      options.scope?.resource ||
+      options.permissions?.appKey ||
+      options.sideNav?.appKey ||
+      null,
+    includeProjectPicker: projectField ? project?.picker !== false : false,
+  }
+}
+
+export const hasAnyProjectScopedResource = (resources, options) =>
+  resources.some((resource) => getResourceScope(resource, options).includeProjectPicker)
+
+export const authOptionsForResource = (resource, options) => {
+  const scope = getResourceScope(resource, options)
+  return scope.resource ? `, { resource: '${scope.resource}' }` : ''
+}
+
+export const unique = (values) => [...new Set(values.filter(Boolean))]
+
+export function replaceMarkedBlock(source, marker, block) {
+  const pattern = new RegExp(`// <${marker}>[\\s\\S]*?// </${marker}>`)
+  return source.replace(pattern, block.trimEnd())
+}
+
+export function removeMarkedBlock(source, marker) {
+  const pattern = new RegExp(`\\n?\\s*// <${marker}>[\\s\\S]*?// </${marker}>\\n?`, 'g')
+  return source.replace(pattern, '\n')
+}
+
+export function removeUnionValue(source, typeName, value) {
+  const unionValue = `  | '${value}'`
+  let next = source.replace(new RegExp(`\\n${escapeRegExp(unionValue)}`, 'g'), '')
+  next = next.replace(
+    new RegExp(`(type ${typeName} = [^\\n]*?)\\s*\\|\\s*'${escapeRegExp(value)}'([^\\n]*)`),
+    '$1$2'
+  )
+  next = next.replace(
+    new RegExp(`(type ${typeName} = )'${escapeRegExp(value)}'\\s*\\|\\s*`),
+    '$1'
+  )
+  return next
+}
+
+export function addUnionValue(source, typeName, value) {
+  const unionValue = `  | '${value}'`
+  if (source.includes(unionValue)) return source
+
+  const pattern = new RegExp(`(type ${typeName} =\\n(?:  \\| '[^']+'\\n?)+)`)
+  const multiLineMatch = source.match(pattern)
+  if (multiLineMatch?.[0].includes(`'${value}'`)) return source
+
+  const next = source.replace(pattern, (match) => `${match.trimEnd()}\n${unionValue}\n`)
+  if (next !== source) return next
+
+  const singleLinePattern = new RegExp(`type ${typeName} = ([^\\n]+)`)
+  return source.replace(singleLinePattern, (match, values) => {
+    if (!values.includes("'")) return match
+    if (values.includes(`'${value}'`)) return match
+    return `type ${typeName} = ${values.trim()} | '${value}'`
+  })
+}
+
+export function addOptionalTypeField(source, typeName, field) {
+  if (source.includes(`  ${field}`)) return source
+
+  const pattern = new RegExp(`(type ${typeName} = \\{[\\s\\S]*?)(\\n\\})`)
+  return source.replace(pattern, `$1\n  ${field}$2`)
+}
+
+export function writeIfChanged(filePath, next) {
+  const current = fs.readFileSync(filePath, 'utf8')
+  if (current === next) return false
+
+  fs.writeFileSync(filePath, next, 'utf8')
+  return true
+}