@typed/template 0.14.0 → 1.0.0-beta.1

package/src/Many.ts

@@ -1,161 +0,0 @@
-/**
- * @since 1.0.0
- */
-import type * as AsyncData from "@typed/async-data/AsyncData"
-import type { Progress } from "@typed/async-data/Progress"
-import * as RefAsyncData from "@typed/fx/AsyncData"
-import * as Fx from "@typed/fx/Fx"
-import * as RefSubject from "@typed/fx/RefSubject"
-import { get, getOption } from "effect/Context"
-import * as Effect from "effect/Effect"
-import { dual } from "effect/Function"
-import { isSome } from "effect/Option"
-import type * as Scope from "effect/Scope"
-import { HydrateContext } from "./internal/HydrateContext.js"
-import { MANY_HOLE } from "./Meta.js"
-import { RenderContext } from "./RenderContext.js"
-import { HtmlRenderEvent, type RenderEvent } from "./RenderEvent.js"
-
-/**
- * @since 1.0.0
- */
-export function many<A, E, R, B extends PropertyKey, R2, E2>(
-  values: Fx.Fx<ReadonlyArray<A>, E, R>,
-  getKey: (a: NoInfer<A>) => B,
-  f: (a: RefSubject.RefSubject<A>, key: B) => Fx.Fx<RenderEvent, E2, R2>
-): Fx.Fx<RenderEvent | ReadonlyArray<RenderEvent>, E | E2, R | R2 | Scope.Scope | RenderContext> {
-  return Fx.fromFxEffect(
-    Effect.contextWith(
-      (context): Fx.Fx<RenderEvent | ReadonlyArray<RenderEvent>, E | E2, R | R2 | RenderContext | Scope.Scope> => {
-        const ctx = get(context, RenderContext)
-        const hydrateContext = getOption(context, HydrateContext)
-
-        if (ctx.environment === "dom" || ctx.environment === "test:dom") {
-          // If we're hydrating, attempt to provide the correct HydrateContext to rendering Fx
-          if (isSome(hydrateContext) && hydrateContext.value.hydrate) {
-            return Fx.keyed(values, {
-              getKey,
-              onValue: (ref, key) =>
-                Fx.provideService(f(ref, key), HydrateContext, { ...hydrateContext.value, manyKey: key.toString() })
-            })
-          }
-
-          // In other environments we just used Fx.keyed to allow indefinite subscriptions to RefSubjects
-          return Fx.keyed(values, {
-            getKey,
-            onValue: f
-          })
-        }
-
-        // When rendering HTML, we want to ensure that we order our HTML events in the same order
-        // as the templates are defined which is why we use mergeOrdered. We also want to ensure that
-        // our templates end, so we take only the first of our source values and also ensure that a subscription
-        // to our RefSubjects only include its first event.
-        return Fx.fromFxEffect(
-          Effect.map(Fx.first(values), (values) =>
-            Fx.mergeOrdered(
-              values.map((value, i) =>
-                Fx.fromFxEffect(Effect.map(RefSubject.of(value), (ref) => {
-                  const key = getKey(value)
-                  return Fx.append(
-                    Fx.map(
-                      f(RefSubject.take(ref, 1), key),
-                      (r) => HtmlRenderEvent((r as HtmlRenderEvent).html, false)
-                    ),
-                    HtmlRenderEvent(MANY_HOLE(key), i === values.length - 1)
-                  )
-                }))
-              )
-            ))
-        )
-      }
-    )
-  )
-}
-
-/**
- * @since 1.0.0
- */
-export const manyAsyncData: {
-  <
-    E1,
-    A,
-    B extends PropertyKey,
-    NoData extends Fx.Fx<any, any, any>,
-    Loading extends Fx.Fx<any, any, any>,
-    Failure extends Fx.Fx<any, any, any>,
-    Success extends Fx.Fx<any, any, any>
-  >(
-    getKey: (a: A) => B,
-    matchers: {
-      NoData: () => NoData
-      Loading: (data: RefSubject.Filtered<Progress>) => Loading
-      Failure: (data: RefSubject.Computed<E1>) => Failure
-      Success: (value: RefSubject.Computed<A>) => Success
-    }
-  ): <E, R>(
-    fx: Fx.Fx<AsyncData.AsyncData<ReadonlyArray<A>, E1>, E, R>
-  ) => Fx.Fx<
-    Fx.Fx.Success<NoData | Loading | Failure | Success>,
-    E | Fx.Fx.Error<NoData | Loading | Failure | Success>,
-    R | Fx.Fx.Context<NoData | Loading | Failure | Success>
-  >
-
-  <
-    R,
-    E,
-    E1,
-    A,
-    B extends PropertyKey,
-    NoData extends Fx.Fx<any, any, any>,
-    Loading extends Fx.Fx<any, any, any>,
-    Failure extends Fx.Fx<any, any, any>,
-    Success extends Fx.Fx<any, any, any>
-  >(
-    fx: Fx.Fx<AsyncData.AsyncData<ReadonlyArray<A>, E1>, E, R>,
-    getKey: (a: A) => B,
-    matchers: {
-      NoData: () => NoData
-      Loading: (data: RefSubject.Filtered<Progress>) => Loading
-      Failure: (data: RefSubject.Computed<E1>) => Failure
-      Success: (value: RefSubject.Computed<A>) => Success
-    }
-  ): Fx.Fx<
-    Fx.Fx.Success<NoData | Loading | Failure | Success>,
-    E | Fx.Fx.Error<NoData | Loading | Failure | Success>,
-    R | Fx.Fx.Context<NoData | Loading | Failure | Success>
-  >
-} = dual(
-  3,
-  <
-    R,
-    E,
-    E1,
-    A,
-    B extends PropertyKey,
-    NoData extends Fx.Fx<RenderEvent, any, any>,
-    Loading extends Fx.Fx<RenderEvent, any, any>,
-    Failure extends Fx.Fx<RenderEvent, any, any>,
-    Success extends Fx.Fx<RenderEvent, any, any>
-  >(
-    fx: Fx.Fx<AsyncData.AsyncData<ReadonlyArray<A>, E1>, E, R>,
-    getKey: (a: A) => B,
-    matchers: {
-      NoData: NoData
-      Loading: (data: RefSubject.Filtered<Progress>) => Loading
-      Failure: (data: RefSubject.Computed<E1>) => Failure
-      Success: (value: RefSubject.Computed<A>, key: B) => Success
-    }
-  ): Fx.Fx<
-    RenderEvent | ReadonlyArray<RenderEvent>,
-    E | Fx.Fx.Error<NoData | Loading | Failure | Success>,
-    R | Fx.Fx.Context<NoData | Loading | Failure | Success>
-  > => {
-    return RefAsyncData.matchAsyncData(fx, {
-      NoData: matchers.NoData,
-      Loading: matchers.Loading,
-      Failure: matchers.Failure,
-      Success: (ref) => many(ref, getKey, matchers.Success)
-    })
-  }
-)

package/src/Meta.ts

@@ -1,45 +0,0 @@
-/**
- * @since 1.0.0
- */
-
-// Used to mark where the typed templates are in the html.
-/**
- * @since 1.0.0
- */
-export const TYPED_START = `<!--typed-start-->`
-/**
- * @since 1.0.0
- */
-export const TYPED_END = `<!--typed-end-->`
-
-/**
- * @since 1.0.0
- */
-export const TYPED_HASH = (hash: string) => `data-typed="${hash}"`
-
-// Inserted into the html to mark where the text starts and ensure separate
-// text nodes are created.
-/**
- * @since 1.0.0
- */
-export const TEXT_START = "<!--text-->"
-
-// Used to mark where a NodePart is in the DOM. It can be found directly after the
-// elements or text nodes it is managing.
-/**
- * @since 1.0.0
- */
-export const TYPED_HOLE_START = (index: number) => `<!--hole${index}-->`
-
-// Used to mark where a NodePart is in the DOM. It can be found directly after the
-// elements or text nodes it is managing.
-/**
- * @since 1.0.0
- */
-export const TYPED_HOLE_END = (index: number) => `<!--/hole${index}-->`
-
-/**
- * Used to mark separation between the start and end of a template.
- * @since 1.0.0
- */
-export const MANY_HOLE = (key: PropertyKey) => `<!--many${key.toString()}-->`

package/src/Part.ts

@@ -1,154 +0,0 @@
-/**
- * @since 1.0.0
- */
-
-import type { Cause } from "effect/Cause"
-import type { Effect } from "effect/Effect"
-import type { Scope } from "effect/Scope"
-import type { ElementSource } from "./ElementSource.js"
-import type { EventHandler } from "./EventHandler.js"
-
-/**
- * @since 1.0.0
- */
-export type Part =
-  | AttributePart
-  | BooleanPart
-  | ClassNamePart
-  | CommentPart
-  | DataPart
-  | EventPart
-  | NodePart
-  | PropertyPart
-  | PropertiesPart
-  | RefPart
-  | TextPart
-
-/**
- * @since 1.0.0
- */
-export interface AttributePart {
-  readonly _tag: "attribute"
-  readonly name: string
-  readonly value: string | null | undefined
-  readonly index: number
-
-  readonly update: (value: this["value"], priority?: number) => Effect<void, never, Scope>
-}
-
-/**
- * @since 1.0.0
- */
-export interface BooleanPart {
-  readonly _tag: "boolean"
-  readonly name: string
-  readonly value: boolean | null | undefined
-  readonly index: number
-
-  readonly update: (value: this["value"], priority?: number) => Effect<void, never, Scope>
-}
-
-/**
- * @since 1.0.0
- */
-export interface ClassNamePart {
-  readonly _tag: "className"
-  readonly value: ReadonlyArray<string>
-  readonly index: number
-
-  readonly update: (value: this["value"], priority?: number) => Effect<void, never, Scope>
-}
-
-/**
- * @since 1.0.0
- */
-export interface DataPart {
-  readonly _tag: "data"
-  readonly value: Readonly<Record<string, string | undefined>> | null | undefined
-  readonly index: number
-
-  readonly update: (value: this["value"], priority?: number) => Effect<void, never, Scope>
-}
-
-/**
- * @since 1.0.0
- */
-export interface EventPart {
-  readonly _tag: "event"
-  readonly name: string
-  readonly source: ElementSource<any>
-  readonly value: null
-  readonly index: number
-  readonly onCause: (cause: Cause<unknown>) => Effect<unknown>
-  readonly addEventListener: (handler: EventHandler<Event>) => void
-}
-
-/**
- * @since 1.0.0
- */
-export interface PropertyPart {
-  readonly _tag: "property"
-  readonly name: string
-  readonly value: unknown
-  readonly index: number
-
-  readonly update: (value: this["value"], priority?: number) => Effect<void, never, Scope>
-}
-
-/**
- * @since 1.0.0
- */
-export interface PropertiesPart {
-  readonly _tag: "properties"
-  readonly value: Record<string, any> | null | undefined
-  readonly index: number
-
-  readonly update: (value: this["value"], priority?: number) => Effect<void, never, Scope>
-}
-
-/**
- * @since 1.0.0
- */
-export interface RefPart<T extends HTMLElement | SVGElement = HTMLElement | SVGElement> {
-  readonly _tag: "ref"
-  readonly value: ElementSource<T>
-  readonly index: number
-}
-
-/**
- * @since 1.0.0
- */
-export interface CommentPart {
-  readonly _tag: "comment"
-  readonly value: string | null | undefined
-  readonly index: number
-
-  readonly update: (value: this["value"], priority?: number) => Effect<void, never, Scope>
-}
-
-/**
- * @since 1.0.0
- */
-export interface TextPart {
-  readonly _tag: "text"
-  readonly value: string | null | undefined
-  readonly index: number
-
-  readonly update: (value: this["value"], priority?: number) => Effect<void, never, Scope>
-}
-
-/**
- * @since 1.0.0
- */
-export interface NodePart {
-  readonly _tag: "node"
-  readonly value: unknown
-  readonly index: number
-
-  readonly update: (value: this["value"], priority?: number) => Effect<void, never, Scope>
-}
-
-/**
- * @since 1.0.0
- */
-export type Parts = ReadonlyArray<Part>

package/src/Placeholder.ts

@@ -1,78 +0,0 @@
-/**
- * @since 1.0.0
- */
-
-import * as Fx from "@typed/fx"
-import "./internal/module-augmentation.js"
-import * as Effect from "effect/Effect"
-import type * as Scope from "effect/Scope"
-
-/**
- * @since 1.0.0
- */
-export const PlaceholderTypeId = Symbol.for("@typed/template/Placholder")
-/**
- * @since 1.0.0
- */
-export type PlaceholderTypeId = typeof PlaceholderTypeId
-
-/**
- * @since 1.0.0
- */
-export interface Placeholder<A = unknown, E = never, R = never> {
-  readonly [PlaceholderTypeId]: {
-    readonly _R: (_: never) => R
-    readonly _E: (_: never) => E
-    readonly _A: (_: never) => A
-  }
-}
-
-/**
- * @since 1.0.0
- */
-export namespace Placeholder {
-  /**
-   * @since 1.0.0
-   */
-  export type Any<A = any> =
-    | Placeholder<A, any, any>
-    | Placeholder<A, never, any>
-    | Placeholder<A>
-    | Placeholder<A, any>
-    | Effect.Effect<A, any, any>
-    // Null/Undefined cannot be modified globally to make them placeholders
-    | ([A] extends [null] ? null : never)
-    | ([A] extends [undefined] ? undefined : never)
-
-  /**
-   * @since 1.0.0
-   */
-  export type Context<T> = [T] extends [never] ? never
-    : T extends Effect.Effect<infer _A, infer _E, infer R> ? R
-    : T extends Placeholder<infer _A, infer _E, infer R> ? R
-    : never
-  /**
-   * @since 1.0.0
-   */
-  export type Error<T> = [T] extends [never] ? never
-    : T extends Effect.Effect<infer _A, infer E, infer _R> ? E
-    : T extends Placeholder<infer _A, infer E, infer _R> ? E
-    : never
-  /**
-   * @since 1.0.0
-   */
-  export type Success<T> = [T] extends [never] ? never
-    : T extends Effect.Effect<infer A, infer _E, infer _R> ? A
-    : T extends Placeholder<infer A, infer _E, infer _R> ? A
-    : never
-
-  export function asRef<A, E = never, R = never>(
-    placeholder: Fx.Fx<A, E, R> | Effect.Effect<A, E, R> | Placeholder<A, E, R> | A
-  ): Effect.Effect<Fx.RefSubject.RefSubject<A, E, never>, never, Scope.Scope | R> {
-    if (Fx.isFx(placeholder) || Effect.isEffect(placeholder)) {
-      return Fx.RefSubject.make(placeholder)
-    } else {
-      return Fx.RefSubject.of(placeholder as A)
-    }
-  }
-}

package/src/Platform.ts

@@ -1,70 +0,0 @@
-/**
- * @since 1.0.0
- */
-
-import type { HttpServerRequest } from "@effect/platform"
-import { Headers, HttpServerResponse } from "@effect/platform"
-import type * as Fx from "@typed/fx/Fx"
-import { toStream } from "@typed/fx/Stream"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-import * as Stream from "effect/Stream"
-import { renderToHtml } from "./Html.js"
-import type { RenderEvent } from "./RenderEvent.js"
-
-const HTML_CONTENT_TYPE = "text/html"
-const CAMEL_CASE_CONTENT_TYPE = { contentType: HTML_CONTENT_TYPE }
-const HYPHENATED_CONTENT_TYPE = { "content-type": HTML_CONTENT_TYPE }
-
-/**
- * @since 1.0.0
- */
-export function htmlResponse<E, R>(
-  fx: Fx.Fx<RenderEvent | null, E, R>,
-  options?: HttpServerResponse.Options
-): Effect.Effect<HttpServerResponse.HttpServerResponse, E, R> {
-  return Effect.contextWithEffect((ctx) =>
-    HttpServerResponse.stream(
-      Stream.provideContext(Stream.encodeText(toStream(renderToHtml(fx))), ctx),
-      {
-        ...CAMEL_CASE_CONTENT_TYPE,
-        ...options,
-        headers: Headers.unsafeFromRecord({ ...HYPHENATED_CONTENT_TYPE, ...options?.headers })
-      }
-    )
-  )
-}
-
-/**
- * @since 1.0.0
- */
-export function htmlResponseString(
-  html: string,
-  options?: HttpServerResponse.Options
-): HttpServerResponse.HttpServerResponse {
-  return HttpServerResponse.raw(
-    html,
-    {
-      ...CAMEL_CASE_CONTENT_TYPE,
-      ...options,
-      headers: Headers.unsafeFromRecord({ ...HYPHENATED_CONTENT_TYPE, ...options?.headers })
-    }
-  )
-}
-
-/**
- * @since 1.0.0
- */
-export function getUrlFromServerRequest(request: HttpServerRequest.HttpServerRequest): URL {
-  const { headers } = request
-  const host = Headers.get(headers, "x-forwarded-host").pipe(
-    Option.orElse(() => Headers.get(headers, "host")),
-    Option.getOrElse(() => "localhost")
-  )
-  const protocol = Headers.get(headers, "x-forwarded-proto").pipe(
-    Option.orElse(() => Headers.get(headers, "protocol")),
-    Option.getOrElse(() => "http")
-  )
-
-  return new URL(request.url, `${protocol}://${host}`)
-}

package/src/RenderContext.ts

@@ -1,121 +0,0 @@
-/**
- * The context in which templates are rendered within
- * @since 1.0.0
- */
-
-import * as Context from "@typed/context"
-import { type DomServices, domServices, type DomServicesElementParams } from "@typed/dom/DomServices"
-import { GlobalThis } from "@typed/dom/GlobalThis"
-import { Window } from "@typed/dom/Window"
-import type { Environment } from "@typed/environment"
-import { CurrentEnvironment } from "@typed/environment"
-import type { Rendered } from "@typed/wire"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import type { Entry } from "./Entry.js"
-
-/**
- * The context in which templates are rendered within
- * @since 1.0.0
- */
-export interface RenderContext {
-  /**
-   * The current environment we are rendering within
-   */
-  readonly environment: Environment
-
-  /**
-   * Cache for root Node's being rendered into.
-   */
-  readonly renderCache: WeakMap<object, Rendered | null>
-
-  /**
-   * Cache for individual templates.
-   */
-  readonly templateCache: WeakMap<TemplateStringsArray, Entry>
-}
-
-/**
- * The context in which templates are rendered within
- * @since 1.0.0
- */
-export const RenderContext: Context.Tagged<RenderContext, RenderContext> = Context.Tagged<RenderContext>(
-  "@typed/template/RenderContext"
-)
-
-/**
- * @since 1.0.0
- */
-export type RenderContextOptions = {
-  readonly environment: Environment
-}
-
-/**
- * @since 1.0.0
- */
-export function make({
-  environment
-}: RenderContextOptions): RenderContext {
-  return {
-    environment,
-    renderCache: new WeakMap(),
-    templateCache: new WeakMap()
-  }
-}
-
-/**
- * @since 1.0.0
- */
-export function getRenderCache<T>(renderCache: RenderContext["renderCache"], key: object): Option.Option<T> {
-  return renderCache.has(key) ? Option.some(renderCache.get(key) as T) : Option.none()
-}
-
-/**
- * @since 1.0.0
- */
-export function getTemplateCache(
-  templateCache: RenderContext["templateCache"],
-  key: TemplateStringsArray
-): Option.Option<Entry> {
-  return Option.fromNullable(templateCache.get(key))
-}
-
-const buildWithCurrentEnvironment = (environment: Environment) =>
-  Layer.mergeAll(
-    RenderContext.layer(make({ environment })),
-    CurrentEnvironment.layer(environment)
-  )
-
-/**
- * @since 1.0.0
- */
-export const dom: (
-  window: Window & GlobalThis,
-  options?: DomServicesElementParams
-) => Layer.Layer<RenderContext | CurrentEnvironment | DomServices> = (
-  window,
-  options
-) =>
-  Layer.provideMerge(
-    Layer.mergeAll(
-      buildWithCurrentEnvironment("dom"),
-      domServices(options)
-    ),
-    Layer.mergeAll(Window.layer(window), GlobalThis.layer(window))
-  )
-
-/**
- * @since 1.0.0
- */
-export const server: Layer.Layer<RenderContext | CurrentEnvironment> = buildWithCurrentEnvironment(
-  "server"
-)
-
-const static_: Layer.Layer<RenderContext | CurrentEnvironment> = buildWithCurrentEnvironment("static")
-
-export {
-  /**
-   * @since 1.0.0
-   */
-  static_ as static
-}