duto 0.0.0 → 0.260808.0

package/src/preact/server.ts

@@ -0,0 +1,186 @@
+// TODO: not used yet
+// import type { AstroComponentMetadata, NamedSSRLoadedRendererValue } from 'astro'
+// import opts from 'astro:preact:opts'
+import { Component as BaseComponent, h, type VNode } from 'preact'
+import { renderToStringAsync } from 'preact-render-to-string'
+
+import { getContext, incrementIslandId } from './context'
+import { restoreSignalsOnProps, serializeSignals } from './signals'
+import StaticHtml from './static-html'
+import type { IslandAttrs } from './types'
+import type { IslandMeta } from '@/types'
+// import type { AstroPreactAttrs, RendererContext } from './types.js'
+// import { createFilter } from '@astrojs/internal-helpers/create-filter'
+
+const slotName = (str: string) => str.trim().replace(/[-_]([a-z])/g, (_, w) => w.toUpperCase())
+
+let originalConsoleError: typeof console.error
+let consoleFilterRefs = 0
+
+// const filter = opts?.include || opts?.exclude ? createFilter(opts.include, opts.exclude) : null;
+
+function setVNodeMask(vNode: VNode<any>, mask: [number, number]) {
+	// Preact's useId derives IDs from an internal root vnode mask (`_mask`/`__m`)
+	// Astro renders each island as a separate root, so without seeding a unique
+	// mask per island, multiple islands can generate colliding IDs
+	// Tracked upstream: https://github.com/preactjs/preact/issues/3781
+	(vNode as VNode<any> & { _mask?: [number, number]; __m?: [number, number] })._mask = mask;
+	(vNode as VNode<any> & { _mask?: [number, number]; __m?: [number, number] }).__m = mask;
+}
+
+export async function check(
+	// this: RendererContext,
+	Component: any,
+	props: Record<string, any>,
+	children: any,
+	metadata?: IslandMeta,
+) {
+	if (typeof Component !== 'function') return false
+	if (Component.name === 'QwikComponent') return false
+
+	const componentUrl = metadata?.componentUrl
+	if (filter && componentUrl && !filter(componentUrl)) {
+		return false;
+	}
+
+	if (Component.prototype != null && typeof Component.prototype.render === 'function') {
+		return BaseComponent.isPrototypeOf(Component)
+	}
+
+	useConsoleFilter()
+
+	try {
+		const { html } = await renderToStaticMarkup(Component, props, children, undefined);
+		if (typeof html !== 'string') {
+			return false;
+		}
+
+		// There are edge cases (SolidJS) where Preact *might* render a string,
+		// but components would be <undefined></undefined>
+		// It also might render an empty string.
+		return html === '' ? false : !html.includes('<undefined>')
+	} catch {
+		return false
+	} finally {
+		finishUsingConsoleFilter()
+	}
+}
+
+function shouldHydrate(metadata: IslandMeta | undefined) {
+	// Adjust how this is hydrated only when the version of Astro supports `astroStaticSlot`
+	return metadata?.astroStaticSlot ? !!metadata.hydrate : true
+}
+
+export async function renderToStaticMarkup(
+	// this: RendererContext,
+	Component: any,
+	props: Record<string, any>,
+	{ default: children, ...slotted }: Record<string, any>,
+	metadata: IslandMeta | undefined,
+) {
+	const ctx = getContext(this.result)
+
+	const slots: Record<string, ReturnType<typeof h>> = {}
+	for (const [key, value] of Object.entries(slotted)) {
+		const name = slotName(key);
+		slots[name] = h(StaticHtml, {
+			hydrate: shouldHydrate(metadata),
+			value,
+			name,
+		}) as VNode<any>
+	}
+
+	// Restore signals back onto props so that they will be passed as-is to components
+	let propsMap = restoreSignalsOnProps(ctx, props)
+
+	const newProps = { ...props, ...slots }
+
+	const attrs: IslandAttrs = {}
+	serializeSignals(ctx, props, attrs, propsMap)
+	const islandId = incrementIslandId(ctx)
+	attrs['id'] = islandId.toString()
+
+	const vNode: VNode<any> = h(
+		Component,
+		newProps,
+		children != null
+			? h(StaticHtml, {
+					hydrate: shouldHydrate(metadata),
+					value: children,
+				})
+			: children,
+	)
+	setVNodeMask(vNode, [islandId, 0])
+
+	const html = await renderToStringAsync(vNode)
+	return { attrs, html }
+}
+
+/**
+ * Reduces console noise by filtering known non-problematic errors
+ *
+ * Performs reference counting to allow parallel usage from async code
+ *
+ * To stop filtering, please ensure that there always is a matching call
+ * to `finishUsingConsoleFilter` afterwards
+ */
+function useConsoleFilter() {
+	consoleFilterRefs++
+
+	if (!originalConsoleError) {
+		originalConsoleError = console.error
+
+		try {
+			console.error = filteredConsoleError
+		} catch {
+			// If we're unable to hook `console.error`, just accept it
+		}
+	}
+}
+
+/**
+ * Indicates that the filter installed by `useConsoleFilter`
+ * is no longer needed by the calling code.
+ */
+function finishUsingConsoleFilter() {
+	consoleFilterRefs--
+
+	// Note: Instead of reverting `console.error` back to the original
+	// when the reference counter reaches 0, we leave our hook installed
+	// to prevent potential race conditions once `check` is made async
+}
+
+/**
+ * Hook/wrapper function for the global `console.error` function.
+ *
+ * Ignores known non-problematic errors while any code is using the console filter.
+ * Otherwise, simply forwards all arguments to the original function.
+ */
+function filteredConsoleError(msg: string, ...rest: any[]) {
+	if (
+		consoleFilterRefs > 0 &&
+		!process.env.DUTO_INTERNAL_TEST_DISABLE_CONSOLE_FILTER &&
+		typeof msg === 'string'
+	) {
+		// In `check`, we attempt to render JSX components through Preact.
+		// When attempting this on a React component, React may output
+		// the following error, which we can safely filter out:
+		const isKnownReactHookError =
+			msg.includes('Invalid hook call.') &&
+			// for React v18 and earlier
+			(msg.includes('https://reactjs.org/link/invalid-hook-call') ||
+				// for React v19 and later
+				msg.includes('https://react.dev/link/invalid-hook-call'))
+		if (isKnownReactHookError) return
+	}
+	originalConsoleError(msg, ...rest)
+}
+
+// const renderer: NamedSSRLoadedRendererValue = {
+// 	name: '@astrojs/preact',
+// 	check,
+// 	renderToStaticMarkup,
+// 	supportsAstroStaticSlot: true,
+// }
+
+// export default renderer

package/src/preact/signals.ts

@@ -0,0 +1,89 @@
+// TODO: not used yet
+// import type { Context } from './context'
+import { incrementId, type Context } from './context'
+import type {
+	ArrayObjectMapping,
+	IslandAttrs,
+	PropNameToSignalMap,
+	SignalLike,
+	Signals,
+	SignalToKeyOrIndexMap,
+} from './types'
+
+function isSignal(x: any): x is SignalLike {
+	return x != null && typeof x === 'object' && typeof x.peek === 'function' && 'value' in x
+}
+
+export function restoreSignalsOnProps(ctx: Context, props: Record<string, any>) {
+	// Restore signal props that were mutated for serialization
+	let propMap: PropNameToSignalMap
+	if (ctx.propsToSignals.has(props)) {
+		propMap = ctx.propsToSignals.get(props)!
+	} else {
+		propMap = new Map()
+		ctx.propsToSignals.set(props, propMap)
+	}
+
+	for (const [key, signal] of propMap)
+		props[key] = signal
+
+	return propMap
+}
+
+export function serializeSignals(
+	ctx: Context,
+	props: Record<string, any>,
+	attrs: IslandAttrs,
+	map: PropNameToSignalMap,
+) {
+	// Check for signals
+	const signals: Signals = {}
+	for (const [key, value] of Object.entries(props)) {
+		const isPropArray = Array.isArray(value)
+		// `typeof null` is 'object' in JS, so we need to check for `null` specifically
+		const isPropObject =
+			!isSignal(value) && typeof props[key] === 'object' && props[key] !== null && !isPropArray
+
+		if (isPropObject || isPropArray) {
+			const values = isPropObject ? Object.keys(props[key]) : value
+			values.forEach((valueKey: number | string, valueIndex: number) => {
+				const signal = isPropObject ? props[key][valueKey] : valueKey
+				if (isSignal(signal)) {
+					const keyOrIndex = isPropObject ? valueKey.toString() : valueIndex
+
+					props[key] = isPropObject
+						? Object.assign({}, props[key], { [keyOrIndex]: signal.peek() })
+						: props[key].map((v: SignalLike, i: number) =>
+								i === valueIndex ? [signal.peek(), i] : v,
+							)
+
+					const currentMap = (map.get(key) || []) as SignalToKeyOrIndexMap
+					map.set(key, [...currentMap, [signal, keyOrIndex]])
+
+					const currentSignals = (signals[key] || []) as ArrayObjectMapping
+					signals[key] = [...currentSignals, [getSignalId(ctx, signal), keyOrIndex]]
+				}
+			})
+		} else if (isSignal(value)) {
+			// Set the value to the current signal value
+			// This mutates the props on purpose, so that it will be serialized correct.
+			props[key] = value.peek()
+			map.set(key, value)
+
+			signals[key] = getSignalId(ctx, value)
+		}
+	}
+
+	if (Object.keys(signals).length)
+		attrs['data-set'] = JSON.stringify(signals)
+}
+
+function getSignalId(ctx: Context, item: SignalLike) {
+	let id = ctx.signals.get(item)
+	if (!id) {
+		id = incrementId(ctx)
+		ctx.signals.set(item, id)
+	}
+
+	return id
+}

package/src/preact/static-html.ts

@@ -0,0 +1,45 @@
+
+
+import { h } from 'preact'
+import { memo } from 'preact/compat'
+
+const StaticHtml = memo(({ value, name, hydrate = true }: {
+  value: string,
+  name?: string,
+  hydrate?: boolean,
+}) => {
+  if (!value) return null
+  const tagName = hydrate ? 'd-b' : 'd-p'
+  return h(tagName, { name, dangerouslySetInnerHTML: { __html: value } })
+}, () => true) // segundo argumento = areEqual, sempre true = nunca re-renderiza
+
+export default StaticHtml
+
+// import { h } from 'preact'
+/**
+ * Duto passes `children` as a string of HTML, so we need
+ * a wrapper `div` to render that content as VNodes
+ *
+ * As a bonus, we can signal to Preact that this subtree is
+ * entirely static and will never change via `shouldComponentUpdate`
+ */
+// const StaticHtml = ({ value, name, hydrate = true }: {
+//   value: string,
+//   name?: string,
+//   hydrate?: boolean,
+// }) => {
+//   if (!value) return null
+//   const tagName = hydrate ? 'd-b': 'd-p' // 'astro-slot' : 'astro-static-slot'
+//   return h(tagName, { name, dangerouslySetInnerHTML: { __html: value } })
+// }
+
+// /**
+//  * This tells Preact to opt-out of re-rendering this subtree
+//  * In addition to being a performance optimization
+//  * this also allows other frameworks to attach to `children`
+//  *
+//  * See https://preactjs.com/guide/v8/external-dom-mutations
+//  */
+// StaticHtml.shouldComponentUpdate = () => false
+
+// export default StaticHtml

package/src/preact/types.ts

@@ -0,0 +1,26 @@
+// import type { SSRResult } from 'astro'
+import type { FilterPattern } from 'vite'
+
+// export type RendererContext = {
+// 	result: SSRResult,
+// }
+
+export type SignalLike = {
+	peek(): any,
+}
+
+export type ArrayObjectMapping = [string, number | string][]
+export type Signals = Record<string, string | ArrayObjectMapping>
+
+export type SignalToKeyOrIndexMap = [SignalLike, number | string][]
+export type PropNameToSignalMap = Map<string, SignalLike | SignalToKeyOrIndexMap>
+
+export type IslandAttrs = {
+	['data-set']?: string,
+	['id']?: string,
+}
+
+export type VirtualModuleOptions = {
+	include?: FilterPattern,
+	exclude?: FilterPattern,
+}