@unitninety/site-kit 0.0.0-stage → 1.6.1

package/src/legacy/languages/identity.ts

@@ -0,0 +1,247 @@
+import type { EditorBlock, EditorField } from '../contract'
+import {
+  STABLE_ID_KEY,
+  type ContentNode,
+  type IdentityFactory,
+  type IdentityResult,
+} from './types'
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)
+
+const validId = (value: unknown): value is string =>
+  typeof value === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(value)
+
+const defaultIdentity: IdentityFactory = () => crypto.randomUUID()
+
+const childrenOf = (field: EditorField, blocks: EditorBlock[]): EditorBlock[] => {
+  if (field.blocks) return field.blocks
+  const bySlug = new Map(blocks.map((block) => [block.slug, block]))
+  return (field.childBlocks ?? []).flatMap((slug) => {
+    const block = bySlug.get(slug)
+    return block ? [block] : []
+  })
+}
+
+type Options = {
+  blocks: EditorBlock[]
+  createId: IdentityFactory
+  forceFresh: boolean
+  refuseIdentityFree: boolean
+  seen: Set<string>
+}
+
+type State = { changed: boolean; problem: null | string }
+
+const freshId = (options: Options): string => {
+  for (let attempts = 0; attempts < 100; attempts += 1) {
+    const candidate = options.createId()
+    if (validId(candidate) && !options.seen.has(candidate)) {
+      options.seen.add(candidate)
+      return candidate
+    }
+  }
+  throw new Error('The identity factory did not produce a fresh stable identifier')
+}
+
+const priorById = (rows: unknown[] | undefined): Map<string, ContentNode> => {
+  const result = new Map<string, ContentNode>()
+  for (const row of rows ?? []) {
+    if (isRecord(row) && validId(row[STABLE_ID_KEY])) result.set(row[STABLE_ID_KEY], row as ContentNode)
+  }
+  return result
+}
+
+const walkFields = (
+  value: ContentNode,
+  fields: EditorField[],
+  previous: ContentNode | undefined,
+  options: Options,
+  state: State,
+  depth: number,
+): ContentNode => {
+  if (depth > 32) {
+    state.problem = 'Content nesting exceeds the stable-identity traversal limit'
+    return value
+  }
+  let output = value
+  const write = (name: string, child: unknown): void => {
+    if (output === value) output = { ...value }
+    output[name] = child
+  }
+
+  for (const field of fields) {
+    if (state.problem) break
+    const current = value[field.name]
+    const prior = previous?.[field.name]
+    if (field.type === 'group') {
+      if (isRecord(current)) {
+        const nested = walkFields(
+          current as ContentNode,
+          field.fields ?? [],
+          isRecord(prior) ? (prior as ContentNode) : undefined,
+          options,
+          state,
+          depth + 1,
+        )
+        if (nested !== current) write(field.name, nested)
+      }
+      continue
+    }
+    if (field.type !== 'array' && field.type !== 'blocks') continue
+    if (current === undefined || current === null) continue
+    if (!Array.isArray(current)) {
+      state.problem = `${field.name} is repeatable content but is not an array`
+      break
+    }
+    const blocks = field.type === 'blocks' ? childrenOf(field, options.blocks) : []
+    const nested = walkRows(
+      current,
+      Array.isArray(prior) ? prior : undefined,
+      (row) =>
+        field.type === 'array'
+          ? field.fields ?? []
+          : blocks.find((block) => block.slug === row.blockType)?.fields ?? [],
+      options,
+      state,
+      depth + 1,
+    )
+    if (nested !== current) write(field.name, nested)
+  }
+  return output
+}
+
+const walkRows = (
+  rows: unknown[],
+  previous: unknown[] | undefined,
+  fieldsFor: (row: ContentNode) => EditorField[],
+  options: Options,
+  state: State,
+  depth: number,
+): ContentNode[] => {
+  const previousIds = priorById(previous)
+  const suppliedCount = rows.filter((row) => isRecord(row) && validId(row[STABLE_ID_KEY])).length
+  if (
+    options.refuseIdentityFree &&
+    (previous?.length ?? 0) > 0 &&
+    rows.length > 0 &&
+    suppliedCount === 0
+  ) {
+    state.problem =
+      'Refusing an identity-free rewrite of existing repeatable content; migrate identities first or preserve _u90id values'
+    return rows.filter(isRecord) as ContentNode[]
+  }
+
+  let changed = false
+  const seenHere = new Set<string>()
+  const output: ContentNode[] = []
+  for (const raw of rows) {
+    if (!isRecord(raw)) {
+      state.problem = 'Repeatable content contains a non-object item that cannot carry a stable identity'
+      return output
+    }
+    const row = raw as ContentNode
+    const supplied = row[STABLE_ID_KEY]
+    const duplicate = validId(supplied) && seenHere.has(supplied)
+    const collides = validId(supplied) && (duplicate || options.seen.has(supplied))
+    if (options.refuseIdentityFree && !options.forceFresh && collides) {
+      state.problem =
+        'Refusing duplicate stable identities during reconciliation; prepare copies with duplicateWithFreshIdentities before insertion'
+      return output
+    }
+    let identity: string
+    if (!options.forceFresh && validId(supplied) && !duplicate && !options.seen.has(supplied)) {
+      identity = supplied
+      options.seen.add(identity)
+    } else {
+      identity = freshId(options)
+      changed = true
+    }
+    seenHere.add(identity)
+    const identified = supplied === identity ? row : { ...row, [STABLE_ID_KEY]: identity }
+    const prior = !options.forceFresh && !duplicate ? previousIds.get(identity) : undefined
+    const nested = walkFields(identified, fieldsFor(identified), prior, options, state, depth)
+    if (nested !== row) changed = true
+    output.push(nested)
+    if (state.problem) return output
+  }
+  if (!changed && output.every((row, index) => row === rows[index])) return rows as ContentNode[]
+  state.changed = true
+  return output
+}
+
+const identify = ({
+  blocks,
+  content,
+  createId = defaultIdentity,
+  forceFresh = false,
+  previous,
+  refuseIdentityFree = false,
+  rootFields,
+}: {
+  blocks: EditorBlock[]
+  content: unknown[]
+  createId?: IdentityFactory
+  forceFresh?: boolean
+  previous?: unknown[]
+  refuseIdentityFree?: boolean
+  rootFields?: EditorField[]
+}): IdentityResult => {
+  const state: State = { changed: false, problem: null }
+  const options: Options = { blocks, createId, forceFresh, refuseIdentityFree, seen: new Set() }
+  try {
+    const walked = walkRows(
+      content,
+      previous,
+      (row) => rootFields ?? blocks.find((block) => block.slug === row.blockType)?.fields ?? [],
+      options,
+      state,
+      0,
+    )
+    return state.problem
+      ? { ok: false, problem: state.problem }
+      : { changed: state.changed, content: walked, ok: true }
+  } catch (error) {
+    return { ok: false, problem: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+/** Explicit one-time migration for content that has never carried identities. */
+export const ensureStableIdentities = (options: {
+  blocks: EditorBlock[]
+  content: unknown[]
+  createId?: IdentityFactory
+}): IdentityResult => identify(options)
+
+/** Existing repeatables must supply identities; positional correspondence is never inferred. */
+export const reconcileStableIdentities = (options: {
+  blocks: EditorBlock[]
+  createId?: IdentityFactory
+  incoming: unknown[]
+  previous: unknown[]
+}): IdentityResult =>
+  identify({
+    blocks: options.blocks,
+    content: options.incoming,
+    createId: options.createId,
+    previous: options.previous,
+    refuseIdentityFree: true,
+  })
+
+/** Clone one section or repeatable row while replacing every identity in its subtree. */
+export const duplicateWithFreshIdentities = ({
+  blocks,
+  createId = defaultIdentity,
+  fields,
+  value,
+}: {
+  blocks: EditorBlock[]
+  createId?: IdentityFactory
+  /** Required when `value` is a repeatable row rather than a section with `blockType`. */
+  fields?: EditorField[]
+  value: Record<string, unknown>
+}): ContentNode => {
+  const result = identify({ blocks, content: [value], createId, forceFresh: true, rootFields: fields })
+  if (!result.ok) throw new Error(result.problem)
+  return result.content[0]!
+}

package/src/legacy/languages/links.ts

@@ -0,0 +1,81 @@
+import { localePrefix, RESERVED_LOCALE_PREFIXES } from './settings'
+import { localePath } from './routing'
+import type { LanguageDefinition } from './types'
+export function languageLinks({
+  languages,
+  locale,
+  logicalPath,
+}: {
+  languages: readonly LanguageDefinition[]
+  locale: string
+  logicalPath: string
+}) {
+  return languages
+    .filter((language) => language.active)
+    .map((language) => {
+      let label = language.label
+      try {
+        label =
+          new Intl.DisplayNames([language.locale], { type: 'language' }).of(language.locale) ??
+          label
+      } catch {
+        /* use configured label on runtimes without this locale */
+      }
+      return {
+        locale: language.locale,
+        label,
+        href: localePath(logicalPath, language.locale),
+        current: language.locale === locale,
+      }
+    })
+}
+
+/** Localize a destination at render time; stored routes and external/factual links stay shared. */
+export function languageHref({
+  href,
+  locale,
+  settings,
+  origin,
+}: {
+  href: string
+  locale: string
+  settings: import('./types').LanguageSettings | null
+  origin?: string
+}): string {
+  if (!settings?.enabled || href.startsWith('#') || href.startsWith('?')) return href
+  let path = href
+  if (!href.startsWith('/')) {
+    if (!origin) return href
+    try {
+      const url = new URL(href, origin)
+      if (url.origin !== new URL(origin).origin) return href
+      path = url.pathname + url.search + url.hash
+    } catch {
+      return href
+    }
+  }
+  if (path.startsWith('//') || path.includes('\\')) return href
+  const [pathname] = path.split(/[?#]/)
+  const first = pathname.split('/').filter(Boolean)[0]
+  if (
+    RESERVED_LOCALE_PREFIXES.some((prefix) => prefix === first) ||
+    pathname.split('/').at(-1)?.includes('.')
+  )
+    return href
+  const configured = settings.languages.find((l) => localePrefix(l.locale) === first?.toLowerCase())
+  if (configured) path = path.slice(first.length + 1) || '/'
+  if (!path.startsWith('/')) path = '/' + path
+  return localePath(path, locale)
+}
+
+export function languageDirection(locale: string): 'ltr' | 'rtl' {
+  try {
+    const language = new Intl.Locale(locale) as Intl.Locale & {
+      textInfo?: { direction: string }
+      getTextInfo?: () => { direction: string }
+    }
+    return (language.getTextInfo?.() ?? language.textInfo)?.direction === 'rtl' ? 'rtl' : 'ltr'
+  } catch {
+    return 'ltr'
+  }
+}

package/src/legacy/languages/resolution.ts

@@ -0,0 +1,56 @@
+import type { EditorField } from '../contract'
+import type { LocalizableField, TranslationField } from './types'
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)
+
+/** Empty rich text means a tree with no non-whitespace text nodes, not merely an empty object. */
+export const isSemanticallyEmpty = (
+  value: unknown,
+  type?: EditorField['type'],
+): boolean => {
+  if (value === undefined || value === null) return true
+  if (typeof value === 'string') return value.trim().length === 0
+  if (type === 'richText' || isRecord(value)) {
+    let prose = ''
+    const visit = (node: unknown): void => {
+      if (typeof node === 'string') {
+        prose += node
+      } else if (Array.isArray(node)) {
+        node.forEach(visit)
+      } else if (isRecord(node)) {
+        if (typeof node.text === 'string') prose += node.text
+        if (node.root !== undefined) visit(node.root)
+        if (node.children !== undefined) visit(node.children)
+      }
+    }
+    visit(value)
+    return prose.trim().length === 0
+  }
+  return false
+}
+
+/** Requested, then configured default, then original; empty candidates never stop fallback. */
+export const resolveField = <T>({
+  fallback,
+  original,
+  requested,
+  type,
+}: {
+  fallback?: T
+  original?: T
+  requested?: T
+  type?: EditorField['type']
+}): T | undefined => {
+  for (const candidate of [requested, fallback, original]) {
+    if (!isSemanticallyEmpty(candidate, type)) return candidate
+  }
+  return undefined
+}
+
+/** A valid Keep original acknowledgment takes precedence over a stored target value. */
+export const languageFieldCandidate = (
+  source: Pick<LocalizableField, 'sourceHash' | 'value'>,
+  target: Pick<TranslationField, 'sourceHash' | 'keepOriginal' | 'value'> | undefined,
+): unknown =>
+  target?.keepOriginal && target.sourceHash === source.sourceHash ? source.value : target?.value

package/src/legacy/languages/routing.ts

@@ -0,0 +1,169 @@
+import {
+  activeLocale,
+  assignedCountryLocale,
+  canonicalLocale,
+  localePrefix,
+  RESERVED_LOCALE_PREFIXES,
+} from './settings'
+import type { LanguageSettings } from './types'
+
+export const selectLocale = (
+  settings: LanguageSettings,
+  request: { country?: string; explicitLocale?: string; preferredLocale?: string },
+): null | string => {
+  if (!settings.enabled) return null
+  const explicit = activeLocale(settings, request.explicitLocale)
+  if (explicit) return explicit
+  const requestedConfiguredLocale =
+    typeof request.explicitLocale === 'string' ? canonicalLocale(request.explicitLocale) : null
+  if (
+    requestedConfiguredLocale &&
+    settings.languages.some(
+      (language) => language.locale.toLowerCase() === requestedConfiguredLocale.toLowerCase(),
+    )
+  ) {
+    return activeLocale(settings, settings.defaultLocale)
+  }
+  return (
+    activeLocale(settings, request.preferredLocale) ??
+    assignedCountryLocale(settings, request.country) ??
+    activeLocale(settings, settings.defaultLocale)
+  )
+}
+
+const splitPath = (path: string): { pathname: string; suffix: string } => {
+  const at = path.search(/[?#]/)
+  return at < 0 ? { pathname: path, suffix: '' } : { pathname: path.slice(0, at), suffix: path.slice(at) }
+}
+
+const siteRelativePath = (path: string): { pathname: string; suffix: string } => {
+  if (typeof path !== 'string' || !path.startsWith('/') || path.startsWith('//') || path.includes('\\')) {
+    throw new TypeError('A site-relative path beginning with one slash is required')
+  }
+  const parts = splitPath(path)
+  return { pathname: parts.pathname || '/', suffix: parts.suffix }
+}
+
+const wellFormedPathname = (pathname: string): boolean => {
+  if (pathname.length > 1 && pathname.includes('//')) return false
+  if (/[\u0000-\u0020\u007f]/.test(pathname) || /%(?![0-9a-f]{2})/i.test(pathname)) return false
+  if (/%(?:2f|5c)/i.test(pathname)) return false
+  try {
+    return pathname
+      .split('/')
+      .filter(Boolean)
+      .every((part) => {
+        const decoded = decodeURIComponent(part)
+        return decoded !== '.' && decoded !== '..'
+      })
+  } catch {
+    return false
+  }
+}
+
+export const localePath = (path: string, locale: string): string => {
+  const prefix = localePrefix(locale)
+  const { pathname, suffix } = siteRelativePath(path)
+  const segments = pathname.split('/').filter(Boolean)
+  if (segments[0]?.toLowerCase() === prefix) {
+    segments[0] = prefix
+    return `/${segments.join('/')}${suffix}`
+  }
+  return pathname === '/' ? `/${prefix}${suffix}` : `/${prefix}${pathname}${suffix}`
+}
+
+const firstSegment = (pathname: string): string =>
+  pathname.split('/').filter(Boolean)[0]?.toLowerCase() ?? ''
+
+const excludedPath = (pathname: string, reservedPrefixes: readonly string[]): boolean => {
+  const reserved = new Set(
+    [...RESERVED_LOCALE_PREFIXES, ...reservedPrefixes].map((value) => value.toLowerCase()),
+  )
+  if (reserved.has(firstSegment(pathname))) return true
+  return (pathname.split('/').filter(Boolean).at(-1) ?? '').includes('.')
+}
+
+const knownPath = (
+  pathname: string,
+  knownPaths: readonly string[] | ((pathname: string) => boolean),
+): boolean =>
+  typeof knownPaths === 'function'
+    ? knownPaths(pathname)
+    : knownPaths.some(
+        (known) =>
+          (splitPath(known).pathname || '/').replace(/\/$/, '') === pathname.replace(/\/$/, ''),
+      )
+
+export type LocaleRequestResult =
+  | { kind: 'pass'; locale: null | string; logicalPath: string }
+  | {
+      cacheControl: 'private, no-store'
+      kind: 'redirect'
+      locale: string
+      status: 307
+      target: string
+    }
+
+/**
+ * Decide whether one public request passes or redirects. Callers supply route existence so
+ * unknown paths, assets, callbacks and preview handlers can never become redirect targets.
+ */
+export const resolveLocaleRequest = (
+  settings: LanguageSettings,
+  request: {
+    country?: string
+    knownPaths: readonly string[] | ((pathname: string) => boolean)
+    path: string
+    preferredLocale?: string
+    reservedPrefixes?: readonly string[]
+  },
+): LocaleRequestResult => {
+  const { pathname, suffix } = siteRelativePath(request.path)
+  if (!settings.enabled) return { kind: 'pass', locale: null, logicalPath: request.path }
+  if (!wellFormedPathname(pathname)) {
+    return { kind: 'pass', locale: null, logicalPath: request.path }
+  }
+
+  const segments = pathname.split('/').filter(Boolean)
+  const configured = settings.languages.find(
+    (language) => localePrefix(language.locale) === segments[0]?.toLowerCase(),
+  )
+  if (configured) {
+    const logicalPathname = segments.length <= 1 ? '/' : `/${segments.slice(1).join('/')}`
+    const logicalPath = `${logicalPathname}${suffix}`
+    if (configured.active) return { kind: 'pass', locale: configured.locale, logicalPath }
+    if (
+      excludedPath(logicalPathname, request.reservedPrefixes ?? []) ||
+      !knownPath(logicalPathname, request.knownPaths)
+    ) {
+      return { kind: 'pass', locale: null, logicalPath: request.path }
+    }
+    const locale = activeLocale(settings, settings.defaultLocale)
+    return locale
+      ? {
+          cacheControl: 'private, no-store',
+          kind: 'redirect',
+          locale,
+          status: 307,
+          target: localePath(logicalPath, locale),
+        }
+      : { kind: 'pass', locale: null, logicalPath: request.path }
+  }
+
+  if (
+    excludedPath(pathname, request.reservedPrefixes ?? []) ||
+    !knownPath(pathname, request.knownPaths)
+  ) {
+    return { kind: 'pass', locale: null, logicalPath: request.path }
+  }
+  const locale = selectLocale(settings, request)
+  return locale
+    ? {
+        cacheControl: 'private, no-store',
+        kind: 'redirect',
+        locale,
+        status: 307,
+        target: localePath(request.path, locale),
+      }
+    : { kind: 'pass', locale: null, logicalPath: request.path }
+}