@typed/template 0.14.0 → 1.0.0-beta.1

package/src/internal/chunks.ts

@@ -1,89 +0,0 @@
-export type TextChunk = {
-  readonly length: number
-  readonly match: RegExpExecArray
-}
-
-export const PART_STRING = (i: number) => `{{__PART${i}__}}`
-
-export const PART_REGEX = /(\{\{__PART(\d+)__\}\})/g
-
-export const getPart = chunker(PART_REGEX)
-
-export const STRICT_PART_REGEX = /^(\{\{__PART(\d+)__\}\})$/g
-
-export const getStrictPart = chunker(STRICT_PART_REGEX)
-
-export const getOpeningTag = chunker(/(\s?<(([a-z0-9-]+:)?[a-z0-9-]+))\s?/gi)
-
-export const getOpeningTagEnd = chunker(/((\s+)?>)/gi)
-
-// Matches the closing of a tag
-// Allows for whitespace between the tag name and the closing brackets
-// allows for namespaced tags
-export const getClosingTag = chunker(/(\s?<\/(\s+)?(([a-z0-9-]+:)?[a-z0-9-]+)(\s+)?>)/gi)
-
-export const getSelfClosingTagEnd = chunker(/(\s+\/>)/gi)
-
-export const getComment = chunker(/(<!--(.+)-->)/gu)
-
-// Get all the text that does not lead to a Part
-// Uses a negative lookahead to ensure to match all text that does not lead to a Part
-export const getTextUntilPart = chunker(/((?:(?!{{__PART\d+__}}).)*)/gi)
-
-// Get all the text that does not lead to a Part
-// Uses a negative lookahead to ensure to match all text that does not lead to a brace
-export const getTextUntilCloseBrace = chunker(/((?:(?!<).)*)/gi)
-
-// Get an attribute and its value within quotes
-export const getAttributeWithQuotes = chunker(
-  /(\s+(([?.@a-z0-9\-_]+:)?[?.@a-z0-9\-_]+)="([^"]*)")/gi
-)
-
-// Get an attribute and its value without quotes up to the next whitespace
-export const getAttributeWithoutQuotes = chunker(
-  /(\s+(([?.@a-z0-9\-_]+:)?[?.@a-z0-9\-_]+)=([^\s>]*))/gi
-)
-
-// Get a boolean attribute up to the next whitespace
-
-export const getBooleanAttribute = chunker(/(\s+(([?.@a-z0-9\-_]+:)?[?.@a-z0-9\-_]+)(?=[\s>]))/gi)
-
-// Takes all text content until </ tagName > with optional whitespace
-export const getAllTextUntilElementClose = (tagName: string) => {
-  return chunker(new RegExp(`([^<]+)(\\s*<\\/${tagName}\\s*>)`, "gi"))
-}
-
-export const getWhitespace = chunker(/(\s+)/g)
-
-const tagNameRegexCache = new Map<string, ReturnType<typeof chunker>>()
-
-const tagNameRegex = (tagName: string) => {
-  return `(<\\/\\s*${tagName}\\s*>)`
-}
-
-export const getClosingTagName = (tagName: string) => {
-  const current = tagNameRegexCache.get(tagName)
-  if (current !== undefined) {
-    return current
-  }
-  const matcher = chunker(new RegExp(tagNameRegex(tagName), "gi"))
-  tagNameRegexCache.set(tagName, matcher)
-  return matcher
-}
-
-function chunker(regex: RegExp) {
-  return (str: string, pos: number): TextChunk | undefined => {
-    regex.lastIndex = pos
-    const match = regex.exec(str)
-    regex.lastIndex = 0
-
-    if (!match || match.index !== pos) {
-      return
-    } else {
-      return {
-        length: match[1].length,
-        match
-      } as const
-    }
-  }
-}

package/src/internal/errors.ts

@@ -1,49 +0,0 @@
-export class CouldNotFindCommentError extends Error {
-  constructor(readonly partIndex: number) {
-    super(`Could not find comment for part ${partIndex}`)
-  }
-}
-
-export class CouldNotFindRootElement extends Error {
-  constructor(readonly partIndex: number) {
-    super(`Could not find root elements for part ${partIndex}`)
-  }
-}
-
-export class CouldNotFindManyCommentError extends Error {
-  constructor(readonly manyIndex: string) {
-    super(`Could not find comment for many part ${manyIndex}`)
-  }
-}
-
-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/external.d.ts

@@ -1,11 +0,0 @@
-declare module "udomdiff" {
-  const udomdiff: (
-    parentNode: Node,
-    current: Array<Node>,
-    updated: Array<Node>,
-    get: (n: Node, x: number) => Node | DocumentFragment | null,
-    before: Node
-  ) => Array<Node>
-
-  export default udomdiff
-}

package/src/internal/indexRefCounter.ts

@@ -1,54 +0,0 @@
-import * as Deferred from "effect/Deferred"
-import * as Effect from "effect/Effect"
-import * as Option from "effect/Option"
-
-export type IndexRefCounter = {
-  release: (index: number) => Effect.Effect<void>
-  expect: (count: number) => Effect.Effect<boolean>
-  wait: Effect.Effect<void>
-}
-
-/**
- * @internal
- */
-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 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)
-  }
-})

package/src/internal/module-augmentation.ts

@@ -1,44 +0,0 @@
-import type { Placeholder } from "../Placeholder.js"
-
-declare global {
-  export interface String extends Placeholder<string> {}
-
-  export interface Number extends Placeholder<number> {}
-
-  export interface Boolean extends Placeholder<boolean> {}
-
-  export interface Symbol extends Placeholder<symbol> {}
-
-  export interface BigInt extends Placeholder<bigint> {}
-
-  export interface Array<T> extends
-    Placeholder<
-      Array<Placeholder.Success<T>>,
-      Placeholder.Error<T>,
-      Placeholder.Context<T>
-    >
-  {}
-
-  export interface ReadonlyArray<T> extends
-    Placeholder<
-      ReadonlyArray<Placeholder.Success<T>>,
-      Placeholder.Error<T>,
-      Placeholder.Context<T>
-    >
-  {}
-
-  // DOM types
-  export interface Node extends Placeholder<Node> {}
-
-  export interface DocumentFragment extends Placeholder<DocumentFragment> {}
-
-  export interface Element extends Placeholder<Element> {}
-
-  export interface HTMLElement extends Placeholder<HTMLElement> {}
-
-  export interface SVGElement extends Placeholder<SVGElement> {}
-}
-
-declare module "@typed/fx/Fx" {
-  export interface Fx<A, E, R> extends Placeholder<A, E, R> {}
-}