fulldev-ui 0.1.64

package/src/utils/getCollectionCascade.ts

@@ -0,0 +1,33 @@
+import {
+  getCollection,
+  type CollectionEntry,
+  type CollectionKey,
+  type ContentCollectionKey,
+  type DataCollectionKey,
+} from 'astro:content'
+import { unflatten } from 'flat'
+import { objectify } from 'radash'
+import { mapValues } from 'remeda'
+
+export type CollectionCascade = {
+  [Key in ContentCollectionKey]: {
+    [Key in CollectionEntry<ContentCollectionKey>['slug']]: any
+  }
+} & {
+  [Key in DataCollectionKey]: {
+    [Key in CollectionEntry<DataCollectionKey>['id']]: any
+  }
+}
+
+export const getCollectionCascade = async (collectionKeys: CollectionKey[]) => {
+  const promises = collectionKeys.map((key) => getCollection(key))
+  const resolved = await Promise.all(promises)
+  const flattened = resolved.flat()
+  const object = objectify(
+    flattened,
+    ({ collection, slug, id }) => `${collection}.${slug || id}`
+  )
+  const mapped = mapValues(object, (value) => value.data)
+  const unflattened = unflatten(mapped)
+  return unflattened as CollectionCascade
+}

package/src/utils/getPathname.ts

@@ -0,0 +1,18 @@
+import type { AstroGlobal } from 'astro'
+import type { CollectionEntry, ContentCollectionKey } from 'astro:content'
+
+export const getPathname = ({
+  slug,
+  collection,
+  data,
+}: CollectionEntry<ContentCollectionKey>):
+  | AstroGlobal['url']['pathname']
+  | undefined => {
+  if (!slug) return
+  if (data.draft) return
+  if (data.output === false) return
+  if (collection === 'pages' && slug === 'index') return '/'
+  if (collection === 'pages') return `/${slug}`
+  if (slug === 'index') return `/${collection}`
+  return `/${collection}/${slug}`
+}

package/src/utils/transform/transform.ts

@@ -0,0 +1,25 @@
+import type { CollectionEntry, CollectionKey } from 'astro:content'
+import { transformCasing } from './transformCasing'
+import { transformReferences } from './transformReferences'
+import { transformSelfs } from './transformSelfs'
+import { transformUnderscores } from './transformUnderscores'
+
+export const transform = async (
+  entry: CollectionEntry<CollectionKey>
+): Promise<any> => {
+  // console.log('entry', entry.data)
+
+  entry = await transformReferences(entry)
+  // console.log('references', entry)
+
+  entry = transformUnderscores(entry)
+  // console.log('underscores', entry)
+
+  entry = transformCasing(entry)
+  // console.log('casing', entry)
+
+  entry = transformSelfs(entry)
+  // console.log('selfs', entry)
+
+  return entry
+}

package/src/utils/transform/transformCasing.ts

@@ -0,0 +1,24 @@
+import { flatten, unflatten } from 'flat'
+import { camel, isObject } from 'radash'
+import { isArray, isString, mapKeys } from 'remeda'
+
+export const transformCasing = (data: any) => {
+  if (!isObject(data) && !isArray(data)) return data
+
+  const flat: any = flatten(data)
+  const transformedData = mapKeys(flat, (key) => {
+    if (!isString(key)) return key
+    const parts = (key as string).split('.')
+    const result = parts.map((part) => {
+      const leadingUnderscores = part.match(/^_+/) || ['']
+      const withoutLeadingUnderscores = part.replace(/^_+/, '')
+      const camelCased = camel(withoutLeadingUnderscores)
+      const result = leadingUnderscores + camelCased
+      return result
+    })
+    return result.join('.')
+  })
+
+  const nested = unflatten(transformedData)
+  return nested
+}

package/src/utils/transform/transformReferences.ts

@@ -0,0 +1,54 @@
+import { getCollection, getEntry, type CollectionKey } from 'astro:content'
+import { flatten, unflatten } from 'flat'
+import { all, get, isString, mapValues } from 'radash'
+import { getPathname } from '../getPathname'
+import { transform } from './transform'
+
+export const transformReferences = async (data: object): Promise<any> => {
+  const flat = flatten(data)
+  const mappedValues = await all(
+    mapValues(flat as any, async (value) => {
+      if (!isString(value)) return value
+      const parts = (value as string).split(' ')
+      const mappedParts = await all(
+        parts.map(async (valuePart) => {
+          if (!valuePart.startsWith('$/')) return valuePart
+
+          const reference = valuePart.split('.')[0].replace('$/', '')
+          const collection = reference.split('/')[0]
+          const slug = reference.split('/').slice(1).join('/')
+          const path = valuePart.split('.').slice(1).join('.')
+
+          if (collection && slug) {
+            let response = await getEntry(collection as CollectionKey, slug)
+            if (!response)
+              throw new Error(`Entry not found: ${collection}/${slug}`)
+            const transformed = await transform(response as any)
+            const result = get(transformed?.data, path)
+            if (!path)
+              return {
+                ...transformed?.data,
+                pathname: getPathname(transformed),
+              }
+            return result ? result : valuePart
+          } else if (collection) {
+            const response = await getCollection(collection as CollectionKey)
+            if (!response)
+              throw new Error(`Entry not found: ${collection}/${slug}`)
+            const mapped = response?.map(async (entry: any) => {
+              const transformed = await transform(entry?.data)
+              return get(transformed, path)
+            })
+            const result = await all(mapped)
+            return result ? result : valuePart
+          }
+
+          return valuePart
+        })
+      )
+      if (mappedParts.length == 1) return mappedParts[0]
+      else return mappedParts.join(' ')
+    })
+  )
+  return unflatten(mappedValues)
+}

package/src/utils/transform/transformSelfs.ts

@@ -0,0 +1,20 @@
+import { flatten, unflatten } from 'flat'
+import { camel, get, isString, mapValues } from 'radash'
+
+export const transformSelfs = (data: any): any => {
+  const flat = flatten(data) as any
+  const mapped = mapValues(flat, (value) => {
+    if (!isString(value)) return value
+    const parts = (value as string).split(' ')
+    const result = parts.map((part) => {
+      if (!part.startsWith('$.')) return part
+      const pathParts = part.replace('$.', '').split('.')
+      const camelCased = pathParts.map((part) => camel(part))
+      const path = 'data.' + camelCased.join('.')
+      const result = get(data, path)
+      return result ? result : part
+    })
+    return result.join(' ')
+  })
+  return unflatten(mapped)
+}

package/src/utils/transform/transformUnderscores.ts

@@ -0,0 +1,19 @@
+import { flatten, unflatten } from 'flat'
+import { isString } from 'radash'
+import { mapKeys } from 'remeda'
+
+export const transformUnderscores = (data: any): any => {
+  const flat: any = flatten(data)
+  const merged = mapKeys(flat, (key) => {
+    if (!isString(key)) return key
+    const parts = key.split('.')
+    const result = parts.map((part) => {
+      return part.replace(/^_+/, '')
+    })
+    const filtered = result.filter(Boolean)
+    const joined = filtered.join('.')
+    return joined
+  })
+  const nested = unflatten(merged)
+  return nested
+}

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+  "extends": "astro/tsconfigs/strict",
+  "compilerOptions": {
+    "jsx": "preserve",
+  }
+}