fulldev-ui 0.1.64

package/src/integration/integration.ts

@@ -0,0 +1,61 @@
+// import type { AstroIntegration } from 'astro'
+// import autoprefixer from 'autoprefixer'
+// import postcssNesting from 'postcss-nesting'
+// import postcssPresetEnv from 'postcss-preset-env'
+// import { mergeDeep } from 'remeda'
+// import virtual from 'vite-plugin-virtual'
+
+// const defaultConfig = {
+//   color: {
+//     accent: 'indigo',
+//     base: 'slate',
+//   },
+//   size: {
+//     scale: 1,
+//     space: 1,
+//     radius: 1,
+//     text: 1,
+//   },
+//   theme: {
+//     border: '1px',
+//   },
+//   font: {
+//     heading.text: 'IMB Plex Sans:700',
+//     subheading.text: 'IMB Plex Sans:700',
+//     text: 'IMB Plex Sans:400',
+//     tagline: 'IMB Plex Sans:400',
+//     button: 'IMB Plex Sans:500',
+//   },
+// }
+
+// export default function fulluiIntegration(userConfig: any): AstroIntegration {
+//   const config: any = mergeDeep(defaultConfig || {}, userConfig || {})
+
+//   return {
+//     name: '/integration',
+//     hooks: {
+//       'astro:config:setup': async ({
+//         // config: astroConfig,
+//         updateConfig,
+//         injectScript,
+//       }) => {
+//         updateConfig({
+//           vite: {
+//             plugins: [
+//               virtual({
+//                 'virtual:/config': `export default ${JSON.stringify(config)}`,
+//               }) as any,
+//             ],
+//             css: {
+//               postcss: {
+//                 plugins: [postcssNesting, postcssPresetEnv, autoprefixer],
+//               },
+//             },
+//           },
+//         })
+
+//         // injectScript('page-ssr', 'import "fulldev-ui/css";')
+//       },
+//     },
+//   }
+// }

package/src/layouts/Layout.astro

@@ -0,0 +1,39 @@
+---
+import type { ComponentProps } from 'astro/types'
+import Tag from '../components/_Tag.astro'
+import Head from '../components/utility/Head.astro'
+import Body from '../components/wrapper/Body.astro'
+
+interface Props extends ComponentProps<typeof Tag> {
+  title: ComponentProps<typeof Head>['title']
+  description: ComponentProps<typeof Head>['description']
+  image: ComponentProps<typeof Head>['image']
+  head?: ComponentProps<typeof Head>
+  body?: ComponentProps<typeof Body>
+}
+
+const { title, description, image, theme, head, body, ...rest } = Astro.props
+---
+
+<Tag
+  class:list={['full-layout']}
+  as="html"
+  if={true}
+  {theme}
+  {...rest}
+>
+  <Head
+    {title}
+    {description}
+    {image}
+    {...head}
+  />
+  <Body
+    if={true}
+    {theme}
+    {...body}
+  >
+    <slot name="before" />
+    <slot />
+  </Body>
+</Tag>

package/src/layouts/todo.md

@@ -0,0 +1,2 @@
+example:
+Layout component should choose which layout. Could also be a local hero. similar behaviour as blocks, but then only layouts.

package/src/schemas/attributesSchema.ts

@@ -0,0 +1,125 @@
+import { z } from 'astro:content'
+
+export const attributesSchema = z.object({
+  abbr: z.any(),
+  accept: z.any(),
+  acceptCharset: z.any(),
+  accessKey: z.any(),
+  allowFullScreen: z.any(),
+  allowTransparency: z.any(),
+  alt: z.any(),
+  async: z.any(),
+  autoComplete: z.any(),
+  autoFocus: z.any(),
+  autoPlay: z.any(),
+  cellPadding: z.any(),
+  cellSpacing: z.any(),
+  challenge: z.any(),
+  charset: z.any(),
+  checked: z.any(),
+  cite: z.any(),
+  class: z.any(),
+  className: z.any(),
+  cols: z.any(),
+  colSpan: z.any(),
+  command: z.any(),
+  content: z.any(),
+  contentEditable: z.any(),
+  contextMenu: z.any(),
+  controls: z.any(),
+  coords: z.any(),
+  crossOrigin: z.any(),
+  data: z.any(),
+  dateTime: z.any(),
+  default: z.any(),
+  defer: z.any(),
+  dir: z.any(),
+  disabled: z.any(),
+  download: z.any(),
+  draggable: z.any(),
+  dropzone: z.any(),
+  encType: z.any(),
+  for: z.any(),
+  form: z.any(),
+  action: z.any(),
+  formEncType: z.any(),
+  method: z.any(),
+  formNoValidate: z.any(),
+  target: z.any(),
+  frameBorder: z.any(),
+  headers: z.any(),
+  height: z.any(),
+  hidden: z.any(),
+  high: z.any(),
+  href: z.any(),
+  hrefLang: z.any(),
+  htmlFor: z.any(),
+  httpEquiv: z.any(),
+  id: z.any(),
+  inputMode: z.any(),
+  isMap: z.any(),
+  itemId: z.any(),
+  itemProp: z.any(),
+  itemRef: z.any(),
+  itemScope: z.any(),
+  itemType: z.any(),
+  kind: z.any(),
+  label: z.any(),
+  lang: z.any(),
+  list: z.any(),
+  loop: z.any(),
+  manifest: z.any(),
+  max: z.any(),
+  maxLength: z.any(),
+  media: z.any(),
+  mediaGroup: z.any(),
+  min: z.any(),
+  minLength: z.any(),
+  multiple: z.any(),
+  muted: z.any(),
+  name: z.any(),
+  noValidate: z.any(),
+  open: z.any(),
+  optimum: z.any(),
+  pattern: z.any(),
+  ping: z.any(),
+  placeholder: z.any(),
+  poster: z.any(),
+  preload: z.any(),
+  rel: z.any(),
+  required: z.any(),
+  rows: z.any(),
+  sizes: z.any(),
+
+  // role: z.any(),
+  // radioGroup: z.any(),
+  // readOnly: z.any(),
+  // rowSpan: z.any(),
+  // sandbox: z.any(),
+  // scope: z.any(),
+  // scoped: z.any(),
+  // scrolling: z.any(),
+  // seamless: z.any(),
+  // selected: z.any(),
+  // shape: z.any(),
+  // size: z.any(),
+  // sortable: z.any(),
+  // span: z.any(),
+  // spellCheck: z.any(),
+  src: z.any(),
+  // srcDoc: z.any(),
+  srcset: z.any(),
+  // start: z.any(),
+  // step: z.any(),
+  style: z.any(),
+  tabIndex: z.any(),
+  title: z.any(),
+  // translate: z.any(),
+  type: z.any(),
+  // typeMustMatch: z.any(),
+  // useMap: z.any(),
+  value: z.any(),
+  width: z.any(),
+  // wmode: z.any(),
+  // wrap: z.any(),
+})

package/src/schemas/htmlAttributesSchema.ts

@@ -0,0 +1,126 @@
+const arr = [
+  'abbr',
+  'accept',
+  'acceptCharset',
+  'accessKey',
+  'action',
+  'allowFullScreen',
+  'allowTransparency',
+  'alt',
+  'async',
+  'autoComplete',
+  'autoFocus',
+  'autoPlay',
+  'cellPadding',
+  'cellSpacing',
+  'challenge',
+  'charset',
+  'checked',
+  'cite',
+  'class',
+  'className',
+  'cols',
+  'colSpan',
+  'command',
+  'content',
+  'contentEditable',
+  'contextMenu',
+  'controls',
+  'coords',
+  'crossOrigin',
+  'data',
+  'dateTime',
+  'default',
+  'defer',
+  'dir',
+  'disabled',
+  'download',
+  'draggable',
+  'dropzone',
+  'encType',
+  'for',
+  'form',
+  'formAction',
+  'formEncType',
+  'formMethod',
+  'formNoValidate',
+  'formTarget',
+  'frameBorder',
+  'headers',
+  'height',
+  'hidden',
+  'high',
+  'href',
+  'hrefLang',
+  'htmlFor',
+  'httpEquiv',
+  'icon',
+  'id',
+  'inputMode',
+  'isMap',
+  'itemId',
+  'itemProp',
+  'itemRef',
+  'itemScope',
+  'itemType',
+  'kind',
+  'label',
+  'lang',
+  'list',
+  'loop',
+  'manifest',
+  'max',
+  'maxLength',
+  'media',
+  'mediaGroup',
+  'method',
+  'min',
+  'minLength',
+  'multiple',
+  'muted',
+  'name',
+  'noValidate',
+  'open',
+  'optimum',
+  'pattern',
+  'ping',
+  'placeholder',
+  'poster',
+  'preload',
+  'radioGroup',
+  'readOnly',
+  'rel',
+  'required',
+  'role',
+  'rows',
+  'rowSpan',
+  'sandbox',
+  'scope',
+  'scoped',
+  'scrolling',
+  'seamless',
+  'selected',
+  'shape',
+  'size',
+  'sizes',
+  'sortable',
+  'span',
+  'spellCheck',
+  'src',
+  'srcDoc',
+  'srcSet',
+  'start',
+  'step',
+  'style',
+  'tabIndex',
+  'target',
+  'title',
+  'translate',
+  'type',
+  'typeMustMatch',
+  'useMap',
+  'value',
+  'width',
+  'wmode',
+  'wrap',
+]

package/src/schemas/pageSchema.ts

@@ -0,0 +1,185 @@
+import {
+  getCollection,
+  getEntries,
+  getEntry,
+  z,
+  type CollectionEntry,
+  type CollectionKey,
+} from 'astro:content'
+import { flatten, unflatten } from 'flat'
+import {
+  all,
+  camel,
+  construct,
+  get,
+  isString,
+  mapValues,
+  objectify,
+} from 'radash'
+import { mapKeys, merge } from 'remeda'
+
+interface Options {
+  casing: boolean
+  layouts: boolean
+  references: boolean
+  selfs: boolean
+}
+
+const defaults: Options = {
+  casing: true,
+  layouts: true,
+  references: true,
+  selfs: true,
+}
+
+let cascade: any = {}
+
+const transformReferences = async (data: object) =>
+  await all(
+    mapValues(flatten(data) as any, async (value) => {
+      if (!isString(value)) return value
+      const parts = (value as string).split(' ')
+      const results = await all(
+        parts.map(async (valuePart) => {
+          if (!valuePart.startsWith('$')) return valuePart
+          if (valuePart.startsWith('$self')) 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)
+            const parsed = await pageSchema().parseAsync(response?.data)
+            // let response: any = get(cascade, `${collection}/${slug}`)
+            const result = get(parsed, path)
+            response = undefined
+            return result
+          } else if (collection) {
+            const response = await getCollection(collection as CollectionKey)
+            // const response: any = get(cascade, collection)
+            const result = response?.map((entry: any) => get(entry?.data, path))
+            return result
+          }
+
+          return valuePart
+        })
+      )
+      if (results.length == 1) return results[0]
+      return results.join(' ')
+    })
+  )
+
+const transformLayouts = (data: object) => {
+  const flat: any = flatten(data)
+  let store: any = {}
+  let i: number = 0
+
+  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 = construct(merged)
+  return nested
+}
+
+const transformSelfs = (data: object) => {
+  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('$self')) return part
+      const pathParts = part.split('.').slice(1)
+      const camelCased = pathParts.map((part) => camel(part))
+      const path = camelCased.join('.')
+      const result = get(data, path)
+      return result ? result : part
+    })
+    return result.join(' ')
+  })
+  return unflatten(mapped)
+}
+
+const transformCasing = (object: object) => {
+  const flat = flatten(object)
+  const mapped = mapKeys(flat, (key) => {
+    if (!isString(key)) return key
+    const parts = (key as string).split('.')
+    const result = parts.map((part) => camel(part))
+    return result.join('.')
+  })
+  return unflatten(mapped)
+}
+
+const buildCascade = async (data: any) => {
+  const flat: any = flatten(data)
+  const values = Object.values(flat)
+  const strings = values.filter(isString)
+  const parts = strings.map((value: any) => value.split(' ')).flat()
+  const fullpaths = parts.filter(
+    (value) => value.startsWith('$') && !value.startsWith('$self')
+  )
+  const filepaths = fullpaths.map((f) => f.replace('$', '').split('.')[0])
+
+  const collections = filepaths.filter((f) => !f.includes('/'))
+  const collectionsNew = collections.filter((c) => !cascade[c])
+  // console.log('collectionsNew', collectionsNew)
+  const collectionsPromises = collectionsNew.map((c) => getCollection(c))
+  const collectionsResponses = await Promise.all(collectionsPromises)
+  const collectionsCascade = objectify(
+    collectionsResponses,
+    (c: any) => c[0]?.collection
+  )
+
+  const entries = filepaths.filter((f) => f.includes('/'))
+  const entriesNew = entries.filter(
+    (e) => !cascade[e.split('/').slice(1).join('/')]
+  )
+  // console.log('entriesNew', entriesNew)
+  const entriesResponses = await getEntries(
+    entriesNew.map((e) => ({
+      collection: e.split('/')[0],
+      slug: e.split('/').slice(1).join('/'),
+    }))
+  )
+  const entriesCascade = objectify(
+    entriesResponses,
+    (e: any) => `${e?.collection}/${e?.slug || e?.id}`
+  )
+
+  cascade = { ...cascade, ...collectionsCascade, ...entriesCascade }
+}
+
+let doIStay = false
+
+export const pageSchema = (options: Partial<Options> = {}) =>
+  z.any().transform(async (data: CollectionEntry<CollectionKey>['data']) => {
+    const { layouts, casing, references, selfs } = merge(defaults, options)
+
+    // console.log('doIStay', doIStay)
+    // console.log('cascade', Object.keys(cascade))
+    doIStay = true
+    // await buildCascade(data)
+
+    if (references) data = await transformReferences(data)
+    // console.log('references', data)
+
+    if (layouts) data = transformLayouts(data)
+    // console.log('layouts', data)
+
+    if (casing) data = transformCasing(data)
+    // console.log('casing', data)
+
+    if (selfs) data = transformSelfs(data)
+    // console.log('selfs', data)
+
+    return data
+  })

package/src/schemas/staticPageSchema.ts

@@ -0,0 +1,124 @@
+import {
+  getCollection,
+  getEntry,
+  z,
+  type CollectionEntry,
+  type CollectionKey,
+} from 'astro:content'
+import { flatten, unflatten } from 'flat'
+import { all, camel, construct, get, isString, mapValues } from 'radash'
+import { mapKeys, merge } from 'remeda'
+
+interface Options {
+  casing: boolean
+  layouts: boolean
+  references: boolean
+  selfs: boolean
+}
+
+const defaults: Options = {
+  casing: true,
+  layouts: true,
+  references: true,
+  selfs: true,
+}
+
+const transformReferences = async (data: object) =>
+  await all(
+    mapValues(flatten(data) as any, async (value) => {
+      if (!isString(value)) return value
+      const parts = (value as string).split(' ')
+      const results = await all(
+        parts.map(async (valuePart) => {
+          if (!valuePart.startsWith('$')) return valuePart
+          if (valuePart.startsWith('$self')) 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)
+            const result = get(response?.data, path)
+            return result
+          } else if (collection) {
+            const response = await getCollection(collection as CollectionKey)
+            const result = response?.map((entry: any) => get(entry?.data, path))
+            return result
+          }
+
+          return valuePart
+        })
+      )
+      if (results.length == 1) return results[0]
+      return results.join(' ')
+    })
+  )
+
+const transformLayouts = (data: object) => {
+  const flat: any = flatten(data)
+  let store: any = {}
+  let i: number = 0
+
+  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 = construct(merged)
+  return nested
+}
+
+const transformSelfs = (data: object) => {
+  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('$self')) return part
+      const pathParts = part.split('.').slice(1)
+      const camelCased = pathParts.map((part) => camel(part))
+      const path = camelCased.join('.')
+      const result = get(data, path)
+      return result ? result : part
+    })
+    return result.join(' ')
+  })
+  return unflatten(mapped)
+}
+
+const transformCasing = (object: object) => {
+  const flat = flatten(object)
+  const mapped = mapKeys(flat, (key) => {
+    if (!isString(key)) return key
+    const parts = (key as string).split('.')
+    const result = parts.map((part) => camel(part))
+    return result.join('.')
+  })
+  return unflatten(mapped)
+}
+
+export const pageSchema = (options: Partial<Options> = {}) =>
+  z.any().transform(async (data: CollectionEntry<CollectionKey>['data']) => {
+    const { layouts, casing, references, selfs } = merge(defaults, options)
+
+    if (references) data = await transformReferences(data)
+    // console.log('references', JSON.stringify(data, null, 2))
+
+    if (layouts) data = transformLayouts(data)
+    // console.log('layouts', data)
+
+    if (casing) data = transformCasing(data)
+    // console.log('casing', data)
+
+    if (selfs) data = transformSelfs(data)
+    // console.log('selfs', data)
+
+    return data
+  })

package/src/types/Childmorphic.ts

@@ -0,0 +1,8 @@
+import type { AstroGlobal } from 'astro'
+
+export type Childmorphic<C extends AstroGlobal['props']> = {
+  [Key in keyof C & string as
+    | Lowercase<Key>
+    | Capitalize<Key>
+    | `${string}${Capitalize<Key>}`]?: C[Key]
+}

package/src/types/Pluralmorphic.ts

@@ -0,0 +1,7 @@
+import type { AstroGlobal } from 'astro'
+
+export type Pluralmorphic<P extends AstroGlobal['props']> =
+  | (P & {
+      [key: number]: P | string
+    })
+  | (P | string)[]

package/src/utils/getAllCollections.ts

@@ -0,0 +1,10 @@
+import type { CollectionKey } from 'astro:content'
+import { getCollection } from 'astro:content'
+
+export const getAllCollections = async (names: CollectionKey[]) => {
+  const promises = names.map((name) => getCollection(name))
+  const resolved = await Promise.all(promises)
+  const flattened = resolved.flat()
+  const filtered = flattened.filter(Boolean)
+  return filtered
+}