@pinegrow/vite-plugin 3.0.72 → 3.0.73-alpha.1

package/astro-runtime.d.ts

@@ -0,0 +1,60 @@
+export interface AstroRuntimeBridgeOptions {
+    markerAttribute?: string
+    root?: Document | Element
+    win?: Window
+    clearPrevious?: boolean
+}
+
+export interface AstroElCacheEntry {
+    el: Element
+    framework: 'astro'
+    isAstro: true
+    sourceId: string
+    pgId: string
+    key: string
+    localFile: string | null
+    sourceFile: string | null
+    nodeType: string | null
+    name: string
+    sourceRange: {
+        start: number | null
+        end: number | null
+        status: string
+    }
+    sourceStart: number | null
+    sourceEnd: number | null
+    sourceRangeStatus: string
+    marker: unknown
+    editability: unknown
+    attributes: unknown[]
+    isFragment: false
+    isRootFragment: false
+    isIsland: false
+    rootEl: null
+    firstEl: Element
+    lastEl: Element
+    instance: null
+    vnode: null
+}
+
+export function createAstroElCacheEntry(input: {
+    element: Element
+    manifest: unknown
+    node: unknown
+}): AstroElCacheEntry
+
+export function createAstroRuntimeBridge(manifest: unknown, options?: AstroRuntimeBridgeOptions): {
+    manifest: unknown
+    scan(root?: Document | Element): unknown
+    refresh(options?: AstroRuntimeBridgeOptions): unknown
+}
+
+export function ensurePinegrowAstroBridge(win?: Window): unknown
+
+export function refreshAstroElCache(manifest: unknown, options?: AstroRuntimeBridgeOptions): unknown
+
+export function scanAstroSourceDomMarkers(
+    root: Document | Element,
+    manifest: unknown,
+    options?: AstroRuntimeBridgeOptions
+): unknown

package/astro.d.ts

@@ -0,0 +1,16 @@
+import type { AstroIntegration } from 'astro'
+import type { LiveDesignerOptions } from './types'
+
+export interface PinegrowAstroModuleOptions {
+    /**
+     * Pinegrow Live Designer options.
+     */
+    liveDesigner?: {
+        [key in string]?: any
+    } & LiveDesignerOptions
+}
+
+declare function pinegrowAstro(moduleOptions?: PinegrowAstroModuleOptions): AstroIntegration
+
+export { pinegrowAstro }
+export default pinegrowAstro

package/dist/adapters/astro/astro-runtime-bridge.js

@@ -0,0 +1,326 @@
+const defaultMarkerAttribute = 'data-pg-source-id'
+const astroFrameworkKey = 'astro'
+
+const createFallbackComputed = getter => ({
+    get value() {
+        return getter()
+    },
+})
+
+const createFallbackRef = value => ({ value })
+
+const readWatchSource = source => {
+    if (typeof source === 'function') {
+        return source()
+    }
+
+    return source?.value
+}
+
+const createFallbackWatch = (source, callback, options = {}) => {
+    if (options.immediate && typeof callback === 'function') {
+        callback(readWatchSource(source), undefined)
+    }
+
+    return () => {}
+}
+
+const createAstroSyntheticInstance = (manifest, node) => ({
+    uid: `astro:${node.id}`,
+    isMounted: true,
+    isUnmounted: false,
+    type: {
+        __name: node.name || 'AstroElement',
+        __file: manifest.sourceFile || null,
+    },
+    appContext: null,
+})
+
+const getDefaultWindow = () => {
+    if (typeof window !== 'undefined') {
+        return window
+    }
+
+    return null
+}
+
+const isMapLike = value =>
+    value &&
+    typeof value.get === 'function' &&
+    typeof value.set === 'function' &&
+    typeof value.delete === 'function' &&
+    typeof value.entries === 'function'
+
+const getMarkerAttribute = (manifest, options = {}) =>
+    options.markerAttribute || manifest?.marker?.attribute || defaultMarkerAttribute
+
+const getManifestSourceKey = manifest => manifest?.sourceFile || manifest?.id || null
+
+const normalizeElCacheEntries = entries => Array.isArray(entries) ? entries : []
+
+const createNodeIndex = manifest => {
+    const index = new Map()
+
+    ;(manifest?.nodes || []).forEach(node => {
+        if (node?.id) {
+            index.set(node.id, node)
+        }
+    })
+
+    return index
+}
+
+const queryMarkerElements = (root, markerAttribute) => {
+    if (!root || typeof root.querySelectorAll !== 'function') {
+        return []
+    }
+
+    return Array.from(root.querySelectorAll(`[${markerAttribute}]`))
+}
+
+const getElementMarkerId = (element, markerAttribute) => {
+    if (!element || typeof element.getAttribute !== 'function') {
+        return null
+    }
+
+    return element.getAttribute(markerAttribute)
+}
+
+const createAstroElCacheEntry = ({ element, manifest, node }) => {
+    const sourceRange = {
+        start: node.sourceStart ?? null,
+        end: node.sourceEnd ?? null,
+        status: node.sourceRangeStatus || 'unknown',
+    }
+
+    return {
+        el: element,
+        framework: astroFrameworkKey,
+        isAstro: true,
+        sourceId: node.id,
+        pgId: node.id,
+        key: node.id,
+        localFile: manifest.sourceFile || null,
+        sourceFile: manifest.sourceFile || null,
+        nodeType: node.type || null,
+        name: node.name || '',
+        sourceRange,
+        sourceStart: sourceRange.start,
+        sourceEnd: sourceRange.end,
+        sourceRangeStatus: sourceRange.status,
+        marker: node.marker || null,
+        editability: node.editability || null,
+        attributes: node.attributes || [],
+        isFragment: false,
+        isRootFragment: false,
+        isIsland: false,
+        rootEl: null,
+        firstEl: element,
+        lastEl: element,
+        instance: createAstroSyntheticInstance(manifest, node),
+        vnode: null,
+    }
+}
+
+const scanAstroSourceDomMarkers = (root, manifest, options = {}) => {
+    const markerAttribute = getMarkerAttribute(manifest, options)
+    const entries = []
+    const missing = []
+
+    if (manifest?.status !== 'ready') {
+        return {
+            status: 'unavailable',
+            markerAttribute,
+            entries,
+            missing,
+            reason: manifest?.reason || 'Astro source manifest is unavailable.',
+        }
+    }
+
+    if (!root || typeof root.querySelectorAll !== 'function') {
+        return {
+            status: 'unavailable',
+            markerAttribute,
+            entries,
+            missing,
+            reason: 'A DOM root with querySelectorAll() is required.',
+        }
+    }
+
+    const nodeIndex = createNodeIndex(manifest)
+
+    queryMarkerElements(root, markerAttribute).forEach(element => {
+        const sourceId = getElementMarkerId(element, markerAttribute)
+        const node = nodeIndex.get(sourceId)
+
+        if (!node) {
+            missing.push({ element, sourceId })
+            return
+        }
+
+        entries.push(createAstroElCacheEntry({ element, manifest, node }))
+    })
+
+    return {
+        status: 'ready',
+        markerAttribute,
+        entries,
+        missing,
+    }
+}
+
+const ensurePinegrowAstroBridge = (win = getDefaultWindow()) => {
+    if (!win) {
+        return null
+    }
+
+    if (!win.pinegrow) {
+        win.pinegrow = {}
+    }
+
+    if (typeof win.pinegrow.reactiveFromContext !== 'function') {
+        win.pinegrow.reactiveFromContext = value => value
+    }
+
+    if (typeof win.pinegrow.refFromContext !== 'function') {
+        win.pinegrow.refFromContext = createFallbackRef
+    }
+
+    if (typeof win.pinegrow.computedFromContext !== 'function') {
+        win.pinegrow.computedFromContext = createFallbackComputed
+    }
+
+    if (typeof win.pinegrow.watchFromContext !== 'function') {
+        win.pinegrow.watchFromContext = createFallbackWatch
+    }
+
+    if (!isMapLike(win.pinegrow.elCache)) {
+        win.pinegrow.elCache = new Map()
+    }
+
+    if (!win.pinegrow.astro) {
+        win.pinegrow.astro = {}
+    }
+
+    if (!isMapLike(win.pinegrow.astro.sourceManifests)) {
+        win.pinegrow.astro.sourceManifests = new Map()
+    }
+
+    return win.pinegrow
+}
+
+const isAstroEntryForSource = (entry, sourceKey) =>
+    entry?.framework === astroFrameworkKey &&
+    (entry.localFile === sourceKey || entry.sourceFile === sourceKey)
+
+const removeAstroEntriesForManifest = (elCache, manifest) => {
+    const sourceKey = getManifestSourceKey(manifest)
+    let removed = 0
+    const elements = []
+
+    if (!sourceKey) {
+        return { elements, removed }
+    }
+
+    Array.from(elCache.entries()).forEach(([element, entries]) => {
+        const currentEntries = normalizeElCacheEntries(entries)
+        const nextEntries = currentEntries.filter(entry => !isAstroEntryForSource(entry, sourceKey))
+        const removedForElement = currentEntries.length - nextEntries.length
+
+        removed += removedForElement
+
+        if (removedForElement) {
+            elements.push(element)
+        }
+
+        if (nextEntries.length) {
+            elCache.set(element, nextEntries)
+        } else {
+            elCache.delete(element)
+        }
+    })
+
+    return { elements, removed }
+}
+
+const upsertAstroEntry = (elCache, entry) => {
+    const existingEntries = normalizeElCacheEntries(elCache.get(entry.el))
+    const nextEntries = existingEntries.filter(existingEntry =>
+        existingEntry.framework !== astroFrameworkKey ||
+        existingEntry.sourceId !== entry.sourceId ||
+        existingEntry.localFile !== entry.localFile
+    )
+
+    nextEntries.push(entry)
+    elCache.set(entry.el, nextEntries)
+}
+
+const refreshAstroElCache = (manifest, options = {}) => {
+    const win = options.win || getDefaultWindow()
+    const root = options.root || win?.document || null
+    const pinegrow = ensurePinegrowAstroBridge(win)
+    const scan = scanAstroSourceDomMarkers(root, manifest, options)
+
+    if (!pinegrow) {
+        return {
+            ...scan,
+            cached: 0,
+            removed: 0,
+            reason: scan.reason || 'A browser window is required.',
+        }
+    }
+
+    if (scan.status !== 'ready') {
+        return {
+            ...scan,
+            cached: 0,
+            removed: 0,
+        }
+    }
+
+    const removal = options.clearPrevious === false
+        ? { elements: [], removed: 0 }
+        : removeAstroEntriesForManifest(pinegrow.elCache, manifest)
+    const updatedElements = new Set(removal.elements)
+
+    scan.entries.forEach(entry => {
+        upsertAstroEntry(pinegrow.elCache, entry)
+        updatedElements.add(entry.el)
+    })
+
+    updatedElements.forEach(element => {
+        if (pinegrow.elUpdateHanderFn) {
+            pinegrow.elUpdateHanderFn(element)
+        }
+    })
+
+    const sourceKey = getManifestSourceKey(manifest)
+
+    if (sourceKey) {
+        pinegrow.astro.sourceManifests.set(sourceKey, manifest)
+    }
+
+    return {
+        ...scan,
+        cached: scan.entries.length,
+        removed: removal.removed,
+    }
+}
+
+const createAstroRuntimeBridge = (manifest, options = {}) => ({
+    manifest,
+    scan: root => scanAstroSourceDomMarkers(
+        root || options.root || options.win?.document || getDefaultWindow()?.document,
+        manifest,
+        options
+    ),
+    refresh: refreshOptions => refreshAstroElCache(manifest, { ...options, ...refreshOptions }),
+})
+
+export {
+    createAstroElCacheEntry,
+    createAstroRuntimeBridge,
+    ensurePinegrowAstroBridge,
+    refreshAstroElCache,
+    scanAstroSourceDomMarkers,
+}