@typed/template 0.9.6 → 0.10.0

package/src/internal/errors.ts

@@ -16,7 +16,34 @@ export class CouldNotFindManyCommentError extends Error {
   }
 }
 
-export function isHydrationError(e: unknown): e is CouldNotFindCommentError | CouldNotFindRootElement {
-  return e instanceof CouldNotFindCommentError || e instanceof CouldNotFindRootElement ||
-    e instanceof CouldNotFindManyCommentError
+export class CouldNotFindTemplateHashError extends Error {
+  constructor(readonly hash: string) {
+    super(`Could not find template hash ${hash}`)
+  }
+}
+
+export class CouldNotFindTemplateEndError extends Error {
+  constructor(readonly hash: string) {
+    super(`Could not find end of template for hash ${hash}`)
+  }
+}
+
+const constructors: Array<Function> = [
+  CouldNotFindCommentError,
+  CouldNotFindRootElement,
+  CouldNotFindManyCommentError,
+  CouldNotFindTemplateHashError,
+  CouldNotFindTemplateEndError
+]
+
+export function isHydrationError(
+  e: unknown
+): e is
+  | CouldNotFindCommentError
+  | CouldNotFindRootElement
+  | CouldNotFindManyCommentError
+  | CouldNotFindTemplateHashError
+  | CouldNotFindTemplateEndError
+{
+  return constructors.some((c) => e instanceof c)
 }

package/src/internal/indexRefCounter.ts

@@ -3,36 +3,6 @@ import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 
 export type IndexRefCounter = {
-  release: (index: number) => Effect.Effect<void>
-  wait: Effect.Effect<void>
-}
-
-/**
- * @internal
- */
-export function indexRefCounter(expected: number): Effect.Effect<IndexRefCounter> {
-  return Effect.map(Deferred.make<void>(), (deferred) => {
-    const done = Deferred.succeed(deferred, undefined)
-    const indexes = new Set<number>(Array.from({ length: expected }, (_, i) => i))
-
-    function release(index: number) {
-      return Effect.suspend(() => {
-        if (indexes.delete(index) && indexes.size === 0) {
-          return done
-        } else {
-          return Effect.unit
-        }
-      })
-    }
-
-    return {
-      release,
-      wait: Deferred.await(deferred)
-    }
-  })
-}
-
-export type IndexRefCounter2 = {
   release: (index: number) => Effect.Effect<void>
   expect: (count: number) => Effect.Effect<boolean>
   wait: Effect.Effect<void>
@@ -41,46 +11,44 @@ export type IndexRefCounter2 = {
 /**
  * @internal
  */
-export function indexRefCounter2(): Effect.Effect<IndexRefCounter2> {
-  return Effect.map(Deferred.make<void>(), (deferred) => {
-    let expected: Option.Option<number> = Option.none<number>()
-    const done = Deferred.succeed(deferred, undefined)
-    const indexes = new Set<number>()
+export const makeRefCounter: Effect.Effect<IndexRefCounter> = Effect.map(Deferred.make<void>(), (deferred) => {
+  let expected: Option.Option<number> = Option.none<number>()
+  const done = Deferred.succeed(deferred, undefined)
+  const indexes = new Set<number>()
+
+  function isDone() {
+    if (Option.isSome(expected)) {
+      return indexes.size === expected.value
+    } else {
+      return false
+    }
+  }
 
-    function isDone() {
-      if (Option.isSome(expected)) {
-        return indexes.size === expected.value
+  function release(index: number) {
+    return Effect.suspend(() => {
+      indexes.add(index)
+      if (isDone()) {
+        return done
       } else {
-        return false
+        return Effect.succeed(false)
       }
-    }
-
-    function release(index: number) {
-      return Effect.suspend(() => {
-        indexes.add(index)
-        if (isDone()) {
-          return done
-        } else {
-          return Effect.succeed(false)
-        }
-      })
-    }
-
-    function expect(count: number) {
-      return Effect.suspend(() => {
-        expected = Option.some(count)
-        if (isDone()) {
-          return Effect.as(done, false)
-        } else {
-          return Effect.succeed(true)
-        }
-      })
-    }
-
-    return {
-      release,
-      expect,
-      wait: Deferred.await(deferred)
-    }
-  })
-}
+    })
+  }
+
+  function expect(count: number) {
+    return Effect.suspend(() => {
+      expected = Option.some(count)
+      if (isDone()) {
+        return Effect.as(done, false)
+      } else {
+        return Effect.succeed(true)
+      }
+    })
+  }
+
+  return {
+    release,
+    expect,
+    wait: Deferred.await(deferred)
+  }
+})

package/src/internal/parser.ts

@@ -2,6 +2,7 @@ import * as Chunk from "effect/Chunk"
 import { globalValue } from "effect/GlobalValue"
 import * as Option from "effect/Option"
 import * as Template from "../Template.js"
+import { convertCharacterEntities } from "./character-entities.js"
 import type { TextChunk } from "./chunks.js"
 import {
   getClosingTagName,
@@ -132,7 +133,6 @@ const tagNameMatches = {
 const attributeMatches = {
   whitespace: isWhitespaceToken,
   equals: isEqualsToken,
-  closingTag: isElementCloseToken,
   openTagEnd: isOpenTagEndToken,
   selfClosingTagEnd: isSelfClosingTagEndToken
 } satisfies Predicates
@@ -149,7 +149,7 @@ const textChildMatches = {
   elementClose: isElementCloseToken
 }
 
-class PathStack {
+export class PathStack {
   chunk: Chunk.Chunk<number> = Chunk.empty()
   count = 0
 
@@ -168,6 +168,10 @@ class PathStack {
   }
 
   toChunk(): Chunk.Chunk<number> {
+    if (Chunk.isEmpty(this.chunk)) {
+      return Chunk.of(this.count)
+    }
+
     return Chunk.append(this.chunk, this.count)
   }
 
@@ -287,12 +291,14 @@ class ParserImpl implements Parser {
       this._skipWhitespace = false
       return [this.addPartWithPrevious(new Template.NodePart(parseInt(next.match[2], 10)))]
     } else if ((next = this.chunk(getWhitespace))) { // Whitespace
-      return this._skipWhitespace ? [] : (this.path.inc(), [new Template.TextNode(next.match[1])])
+      return this._skipWhitespace
+        ? []
+        : (this.path.inc(), [new Template.TextNode(convertCharacterEntities(next.match[1]))])
     } else if ((next = this.chunk(getTextUntilCloseBrace))) { // Text and parts
       return parseTextAndParts(next.match[1], (i) => this.addPartWithPrevious(new Template.NodePart(i)))
     } else {
       this.path.inc()
-      return [new Template.TextNode(this.nextChar())]
+      return [new Template.TextNode(convertCharacterEntities(this.nextChar()))]
     }
   }
 
@@ -410,12 +416,6 @@ class ParserImpl implements Parser {
         this.consumeAmount(2)
         this.context = "unknown"
 
-        return BREAK_ATTR
-      }
-      case "closingTag": {
-        this.consumeAmount(name.length)
-        this.context = "unknown"
-
         return BREAK_ATTR
       }
     }
@@ -532,17 +532,17 @@ class ParserImpl implements Parser {
         this.consumeAmount(8)
         const part = this.parsePartToken((i) => this.addPartWithPrevious(new Template.TextPartNode(i)))
 
-        return text === "" ? Continue([part]) : Continue([new Template.TextNode(text), part])
+        return text === "" ? Continue([part]) : Continue([new Template.TextNode(convertCharacterEntities(text)), part])
       }
       case "elementClose": {
         this.consumeClosingTag(tagName)
         return Break(
-          text ? [new Template.TextNode(text)] : undefined
+          text ? [new Template.TextNode(convertCharacterEntities(text))] : undefined
         )
       }
       case "elementOpen": // In this case we make the assumption that you forgot to close this element
         return Break(
-          text ? [new Template.TextNode(text)] : undefined
+          text ? [new Template.TextNode(convertCharacterEntities(text))] : undefined
         )
     }
   }
@@ -670,7 +670,7 @@ class ParserImpl implements Parser {
   }
 }
 
-function templateWithParts(template: ReadonlyArray<string>): string {
+export function templateWithParts(template: ReadonlyArray<string>): string {
   const length = template.length
   const lastIndex = length - 1
 
@@ -689,7 +689,7 @@ function templateWithParts(template: ReadonlyArray<string>): string {
   return output
 }
 
-function unsafeParsePartIndex(text: string): number {
+export function unsafeParsePartIndex(text: string): number {
   const next = getStrictPart(text, 0)
 
   if (!next) {
@@ -699,13 +699,13 @@ function unsafeParsePartIndex(text: string): number {
   return parseInt(next.match[2], 10)
 }
 
-function parseTextAndParts<T>(s: string, f: (index: number) => T): Array<Template.TextNode | T> {
+export function parseTextAndParts<T>(s: string, f: (index: number) => T): Array<Template.TextNode | T> {
   let next: TextChunk | undefined
   let pos: number = 0
   const out: Array<Template.TextNode | T> = []
 
   if (!PART_REGEX.test(s)) {
-    return [new Template.TextNode(s)]
+    return [new Template.TextNode(convertCharacterEntities(s))]
   }
 
   while (pos < s.length) {
@@ -713,7 +713,7 @@ function parseTextAndParts<T>(s: string, f: (index: number) => T): Array<Templat
       out.push(f(parseInt(next.match[2], 10)))
       pos += next.length
     } else if ((next = getTextUntilPart(s, pos))) {
-      out.push(new Template.TextNode(next.match[1]))
+      out.push(new Template.TextNode(convertCharacterEntities(next.match[1])))
 
       pos += next.length
     } else {
@@ -722,7 +722,7 @@ function parseTextAndParts<T>(s: string, f: (index: number) => T): Array<Templat
   }
 
   if (pos < s.length) {
-    out.push(new Template.TextNode(s.slice(pos)))
+    out.push(new Template.TextNode(convertCharacterEntities(s.slice(pos))))
   }
 
   return out