liminal 0.5.2 → 0.5.3

package/types/types_derived/taggedUnion.ts

@@ -1,30 +0,0 @@
-import type { JSONKey } from "../../util/JSONKey.ts"
-import type { JSONConstType } from "../const.ts"
-import { type JSONObjectType, object } from "../object.ts"
-import type { JSONStringType } from "../string.ts"
-import { type Type } from "../Type.ts"
-import { type NormalizeTypeLikeJ, type NormalizeTypeLikeT, type TypeLike } from "../TypeLike.ts"
-import { _union, type JSONUnionType, union } from "../union.ts"
-
-export function taggedUnion<const M extends TaggedUnionMembers, K extends Extract<keyof M, string>>(members: M): Type<
-  {
-    [L in K]: {
-      type: L
-      value: NormalizeTypeLikeT<M[L]>
-    }
-  }[K],
-  JSONUnionType<
-    {
-      [L in K]: JSONObjectType<{
-        type: JSONConstType<JSONStringType, L>
-        value: NormalizeTypeLikeJ<M[L]>
-      }>
-    }[K]
-  >
-> {
-  return union(
-    ...Object.entries(members).map(([type, value]) => object({ type, value })),
-  ) as never
-}
-
-export type TaggedUnionMembers = Record<JSONKey, TypeLike>

package/types/types_derived/wrapper.ts

@@ -1,10 +0,0 @@
-import { type JSONObjectType, object } from "../object.ts"
-import type { Type } from "../Type.ts"
-import type { NormalizeTypeLikeJ, NormalizeTypeLikeT, TypeLike } from "../TypeLike.ts"
-
-export function wrapper<X extends TypeLike>(value: X): Type<
-  { value: NormalizeTypeLikeT<X> },
-  JSONObjectType<{ value: NormalizeTypeLikeJ<X> }>
-> {
-  return object({ value }) as never
-}

package/types/union.ts

@@ -1,19 +0,0 @@
-import type { JSONType } from "./JSONType.ts"
-import type { JSONTypeBase } from "./JSONTypeBase.ts"
-import { makeType } from "./makeType.ts"
-import type { Type } from "./Type.ts"
-import { normalizeTypeLike, type NormalizeTypeLikeJ, type NormalizeTypeLikeT, type TypeLike } from "./TypeLike.ts"
-
-export function union<const M extends Array<TypeLike>>(
-  ...members: M
-): Type<NormalizeTypeLikeT<M[number]>, JSONUnionType<NormalizeTypeLikeJ<M[number]>>> {
-  return _union(...members.map(normalizeTypeLike)) as never
-}
-
-export function _union(...members: Array<Type>): Type {
-  return makeType(() => _union, members)
-}
-
-export interface JSONUnionType<M extends JSONType = any> extends JSONTypeBase {
-  anyOf: Array<M>
-}

package/util/ArrayOfLength.ts

@@ -1,5 +0,0 @@
-export type ArrayOfLength<
-  T,
-  L extends number,
-  A extends Array<T> = [],
-> = number extends L ? Array<T> : L extends A["length"] ? A : ArrayOfLength<T, L, [...A, T]>

package/util/DeferredOr.ts

@@ -1 +0,0 @@
-export type DeferredOr<T> = T | (() => T)

package/util/EnsureNarrow.ts

@@ -1,5 +0,0 @@
-export type EnsureNarrow<V> = unknown extends V ? [error: typeof WIDENING_TYPE_DISALLOWED]
-  : [V] extends [never] ? [error: typeof WIDENING_TYPE_DISALLOWED]
-  : []
-
-export declare const WIDENING_TYPE_DISALLOWED: unique symbol

package/util/EnsureRecord.ts

@@ -1,3 +0,0 @@
-import type { TupleToRecord } from "./TupleToRecord.ts"
-
-export type EnsureRecord<T> = T extends Array<any> ? TupleToRecord<T> : T

package/util/Expand.ts

@@ -1 +0,0 @@
-export type Expand<T> = T extends T ? { [K in keyof T]: T[K] } : never

package/util/Falsy.ts

@@ -1 +0,0 @@
-export type Falsy = false | 0 | 0n | "" | null | undefined

package/util/FromEntries.ts

@@ -1,3 +0,0 @@
-export type FromEntries<E extends [keyof any, any]> = {
-  [K in E[0]]: Extract<E, [K, any]> extends [K, infer V] ? V : never
-}

package/util/IteratorLike.ts

@@ -1 +0,0 @@
-export type IteratorLike<Y = any, O = any> = Iterator<Y, O> | AsyncIterator<Y, O>

package/util/JSONEntry.ts

@@ -1,3 +0,0 @@
-import type { JSONKey } from "./JSONKey.ts"
-
-export type JSONEntry<V = any> = [JSONKey, V]

package/util/JSONKey.ts

@@ -1 +0,0 @@
-export type JSONKey = number | string

package/util/JSONObject.ts

@@ -1,6 +0,0 @@
-import type { JSONKey } from "./JSONKey.ts"
-import type { JSONValue } from "./JSONValue.ts"
-
-export type JSONObject = {
-  [value: JSONKey]: JSONValue
-}

package/util/JSONSchemaMemo.ts

@@ -1,15 +0,0 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec"
-import { toJSONSchema } from "standard-json-schema"
-import { isType } from "../types/Type.ts"
-
-const memo = new WeakMap<StandardSchemaV1, Promise<object>>()
-
-export function JSONSchemaMemo(type: StandardSchemaV1): Promise<object> {
-  let pending = memo.get(type)
-  if (pending) {
-    return pending
-  }
-  pending = isType(type) ? Promise.resolve(type.toJSON()) : toJSONSchema(type)
-  memo.set(type, pending)
-  return pending
-}

package/util/JSONValue.ts

@@ -1,3 +0,0 @@
-import type { JSONObject } from "./JSONObject.ts"
-
-export type JSONValue = null | boolean | number | string | Array<JSONValue> | JSONObject

package/util/PromiseOr.ts

@@ -1 +0,0 @@
-export type PromiseOr<T> = T | Promise<T>

package/util/Result.ts

@@ -1,7 +0,0 @@
-export type Result<T, E> = {
-  value: T
-  thrown?: never
-} | {
-  value?: never
-  thrown: E
-}

package/util/Taggable.ts

@@ -1,18 +0,0 @@
-import { applyTemplateWithIndentation } from "./fixTemplateStrings.ts"
-import { isTemplateStringsArray } from "./isTemplateStringsArray.ts"
-
-export interface Taggable<A extends Array<any>> {
-  (template: TemplateStringsArray, ...substitutions: Array<string>): this
-  (...values: A): this
-}
-
-export type TaggableArgs<A extends Array<any>> = A | [
-  raw: TemplateStringsArray,
-  ...substitutions: Array<string>,
-]
-
-export function normalizeTaggableArgs<A extends Array<unknown>>(...[e0, ...eRest]: TaggableArgs<A>) {
-  return isTemplateStringsArray(e0)
-    ? [applyTemplateWithIndentation(e0, ...eRest)] as [string]
-    : [e0, ...eRest] as A
-}

package/util/TupleToRecord.ts

@@ -1,5 +0,0 @@
-export type TupleToRecord<T extends Array<any>> = [
-  {
-    [K in keyof T as K extends `${number}` ? K : never]: T[K]
-  },
-][0]

package/util/assert.ts

@@ -1,7 +0,0 @@
-import { LiminalAssertionError } from "../LiminalAssertionError.ts"
-
-export function assert(expr: unknown, msg = ""): asserts expr {
-  if (!expr) {
-    throw new LiminalAssertionError(msg)
-  }
-}

package/util/dedent.ts

@@ -1,5 +0,0 @@
-import { fixTemplateStrings } from "./fixTemplateStrings.ts"
-
-export function dedent(input: TemplateStringsArray, ...values: Array<unknown>): string {
-  return String.raw(fixTemplateStrings(input), ...values)
-}

package/util/fixTemplateStrings.test.ts

@@ -1,250 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { applyTemplateWithIndentation, fixTemplateStrings } from "./fixTemplateStrings"
-
-// Helper to create a mock TemplateStringsArray
-function createTemplateArray(strings: string[]): TemplateStringsArray {
-  const arr = [...strings] as unknown as TemplateStringsArray
-  Object.defineProperty(arr, "raw", { value: strings })
-  return arr
-}
-
-// A template tag function that applies indentation to substitutions
-function templateTag(strings: TemplateStringsArray, ...values: any[]): string {
-  return applyTemplateWithIndentation(strings, ...values)
-}
-
-describe("fixTemplateStrings", () => {
-  test("handles basic template strings without indentation", () => {
-    const template = createTemplateArray(["hello", "world", "!"])
-    const result = fixTemplateStrings(template)
-    expect(result.raw).toEqual(["hello", "world", "!"])
-  })
-
-  test("removes common indentation from multiline strings", () => {
-    const template = createTemplateArray([`
-        first line
-        second line
-        third line`])
-
-    const result = fixTemplateStrings(template)
-    // Leading newline should be removed
-    expect(result.raw[0]).toBe("first line\nsecond line\nthird line")
-  })
-
-  test("handles escaped characters", () => {
-    const template = createTemplateArray(["\\`template\\$\\{with\\}escaped\\nchars"])
-    const result = fixTemplateStrings(template)
-    // The function only unescapes backticks, dollar signs, and opening braces
-    expect(result.raw[0]).toBe("`template${with\\}escaped\\nchars")
-  })
-
-  test("preserves intended backticks and dollar signs", () => {
-    const template = createTemplateArray(["const code = `const value = ${'test'}`"])
-    const result = fixTemplateStrings(template)
-    expect(result.raw[0]).toBe("const code = `const value = ${'test'}`")
-  })
-
-  test("removes trailing spaces in last segment", () => {
-    const template = createTemplateArray([`
-        some text
-        with trailing spaces   
-        `])
-
-    const result = fixTemplateStrings(template)
-    // The function only removes trailing spaces after a newline at the end
-    // And only if indentation is detected
-    // Leading newline should be removed
-    expect(result.raw[0]).toBe("some text\nwith trailing spaces   \n")
-  })
-
-  test("handles mixed indentation", () => {
-    const template = createTemplateArray([`
-        spaces here
-          more spaces
-      less spaces
-            most spaces`])
-
-    const result = fixTemplateStrings(template)
-    // The function uses the indentation of the first line as the baseline
-    // Leading newline should be removed
-    expect(result.raw[0]).toBe("spaces here\n  more spaces\n      less spaces\n    most spaces")
-  })
-
-  test("removes escaped newlines", () => {
-    const template = createTemplateArray(["first line\\\nsecond line\\\nthird line"])
-    const result = fixTemplateStrings(template)
-    expect(result.raw[0]).toBe("first linesecond linethird line")
-  })
-
-  test("handles multiple segments with indentation", () => {
-    const template = createTemplateArray([
-      `
-        first \${`,
-      `}
-        second \${`,
-      `}
-        third
-      `,
-    ])
-
-    const result = fixTemplateStrings(template)
-    // Leading newline should be removed in first segment only
-    expect(result.raw).toEqual([
-      "first ${",
-      "}\nsecond ${",
-      "}\nthird",
-    ])
-  })
-})
-
-describe("templateTag with indentation", () => {
-  test("basic template with substitution", () => {
-    const result = templateTag`Hello ${"world"}!`
-    expect(result).toBe("Hello world!")
-  })
-
-  test("multiline template with indentation", () => {
-    const result = templateTag`
-      This is a multiline
-      string with proper indentation
-    `
-    // Leading newline should be removed
-    expect(result).toBe("This is a multiline\nstring with proper indentation")
-  })
-
-  test("template with multiline substitution without indentation", () => {
-    const multilineValue = "line1\nline2\nline3"
-    const result = templateTag`Value: ${multilineValue}`
-    // The substitution doesn't get indentation because there's no preceding newline
-    expect(result).toBe("Value: line1\nline2\nline3")
-  })
-
-  test("template with multiline substitution with indentation", () => {
-    const multilineValue = "line1\nline2\nline3"
-    const result = templateTag`
-      Values:
-        ${multilineValue}
-      End of values
-    `
-    // The substitution should get the indentation from before the ${}
-    // Leading newline should be removed
-    expect(result).toBe("Values:\n  line1\n  line2\n  line3\nEnd of values")
-  })
-
-  test("nested indentation with multiline values", () => {
-    const codeBlock = "function example() {\n  console.log('test');\n}"
-    const result = templateTag`
-      Here is some code:
-        ${codeBlock}
-      End of code
-    `
-    // The function should preserve the internal indentation of the code block
-    // Leading newline should be removed
-    expect(result).toBe("Here is some code:\n  function example() {\n    console.log('test');\n  }\nEnd of code")
-  })
-
-  test("mixed indentation with tabs and spaces", () => {
-    const tabIndentedValue = "line1\n\tline2\n\t\tline3"
-    const result = templateTag`
-      Tab indented:
-        ${tabIndentedValue}
-      End
-    `
-    // Space indentation should be applied to all lines including those with tabs
-    // Leading newline should be removed
-    expect(result).toBe("Tab indented:\n  line1\n  \tline2\n  \t\tline3\nEnd")
-  })
-
-  test("numbered list with indented content", () => {
-    const listItems = "1\n2\n3"
-    const result = templateTag`
-      1. Part one:
-        ${listItems}
-      2. Part two
-    `
-    // This is specifically testing the case mentioned by the user
-    // Leading newline should be removed
-    expect(result).toBe("1. Part one:\n  1\n  2\n  3\n2. Part two")
-  })
-
-  test("complex nested structures", () => {
-    const jsonData = `{
-  "name": "example",
-  "values": [1, 2, 3]
-}`
-    const code = `function test() {
-  if (condition) {
-    return true;
-  }
-  return false;
-}`
-
-    const result = templateTag`
-      JSON data:
-        ${jsonData}
-      
-      Code:
-        ${code}
-      
-      End of examples
-    `
-
-    // The code gets additional indentation due to the spacing before the interpolation
-    // Leading newline should be removed
-    expect(result).toBe(`JSON data:
-  {
-    "name": "example",
-    "values": [1, 2, 3]
-  }
-
-Code:
-  function test() {
-    if (condition) {
-      return true;
-    }
-    return false;
-  }
-
-End of examples`)
-  })
-
-  test("preserves indentation within code blocks", () => {
-    const code = `if (true) {
-  console.log("indented");
-    console.log("double indented");
-}`
-
-    const result = templateTag`
-      Code example:
-        ${code}
-      End
-    `
-
-    // The indentation is applied to each line based on the template's indentation
-    // Leading newline should be removed
-    expect(result).toBe(`Code example:
-  if (true) {
-    console.log("indented");
-      console.log("double indented");
-  }
-End`)
-  })
-
-  test("handles empty lines in substitutions", () => {
-    const textWithEmptyLines = "line1\n\nline3"
-
-    const result = templateTag`
-      Text:
-        ${textWithEmptyLines}
-      End
-    `
-
-    // Empty lines also get indentation
-    // Leading newline should be removed
-    expect(result).toBe(`Text:
-  line1
-  
-  line3
-End`)
-  })
-})

package/util/fixTemplateStrings.ts

@@ -1,99 +0,0 @@
-const INDENTATION_RE = /^\n([ \t]+)/
-const ESCAPE_SEQ_RE = /\\([`${\\]|\n)/g
-const LAST_INDENTATION_RE = /\n[ \t]+$/
-
-export function fixTemplateStrings(template: TemplateStringsArray): { readonly raw: readonly string[] } {
-  const firstSegment = template.raw[0]!
-  const leadingIndentMatch = INDENTATION_RE.exec(firstSegment)
-  const indentation = leadingIndentMatch?.[1]
-
-  const rawLength = template.raw.length
-  const result = new Array(rawLength)
-
-  for (let i = 0; i < rawLength; i++) {
-    let str = template.raw[i]!
-    // Only perform common indentation replacements if needed
-    if (indentation) {
-      // Remove leading newline and indentation in the first segment
-      if (i === 0) {
-        str = str.slice(indentation.length + 1)
-      }
-      // Use a simple string replacement with a regular expression for better performance
-      str = str.replaceAll(`\n${indentation}`, "\n")
-    }
-
-    // Replace common escape sequences in a single pass
-    str = str.replace(ESCAPE_SEQ_RE, (_match, char) => {
-      // Keep the escaped newline replacement separate for clarity
-      return char === "\n" ? "" : char
-    })
-
-    // Handle trailing spaces only for the last segment
-    if (indentation && i === rawLength - 1) {
-      str = str.replace(LAST_INDENTATION_RE, "")
-    }
-
-    result[i] = str
-  }
-
-  return { raw: result }
-}
-
-const LEADING_SPACE_RE = /^([ \t]*)/
-/**
- * Applies template string indentation to substituted values with line breaks
- *
- * @param strings - The template strings array (processed through fixTemplateStrings)
- * @param values - The substitution values
- * @returns - The formatted string with properly indented substitutions
- */
-export function applyTemplateWithIndentation(strings: TemplateStringsArray, ...values: any[]): string {
-  const fixedStrings = fixTemplateStrings(strings)
-  const rawArr = fixedStrings.raw
-  const valuesLength = values.length
-
-  const resultParts = new Array(Math.max(1, rawArr.length * 2 - 1))
-  let resultIndex = 0
-
-  for (let i = 0; i < rawArr.length; i++) {
-    const str = rawArr[i] || ""
-    resultParts[resultIndex++] = str
-
-    // Only process values for non-final segments
-    if (i < valuesLength) {
-      const value = String(values[i])
-
-      // If value has line breaks, we should indent it
-      if (value.includes("\n")) {
-        const lastNewlineIndex = str.lastIndexOf("\n")
-
-        if (lastNewlineIndex !== -1) {
-          // Extract the indentation after the last newline
-          const textAfterLastNewline = str.substring(lastNewlineIndex + 1)
-          const leadingSpaceMatch = LEADING_SPACE_RE.exec(textAfterLastNewline)
-          const indentationToApply = leadingSpaceMatch && leadingSpaceMatch[1] ? leadingSpaceMatch[1] : ""
-
-          if (indentationToApply) {
-            // Split the value into lines once
-            const lines = value.split("\n")
-            const linesLength = lines.length
-
-            // First line doesn't need indentation
-            resultParts[resultIndex++] = lines[0]
-
-            // Apply indentation to subsequent lines
-            for (let j = 1; j < linesLength; j++) {
-              resultParts[resultIndex++] = "\n" + indentationToApply + lines[j]
-            }
-            continue
-          }
-        }
-      }
-      // For simple values or when no indentation is needed
-      resultParts[resultIndex++] = value
-    }
-  }
-
-  // Combine all parts at once
-  return resultParts.slice(0, resultIndex).join("")
-}

package/util/isAsyncIterator.ts

@@ -1,6 +0,0 @@
-export function isAsyncIterator(value: unknown): value is AsyncIteratorObject<unknown, unknown, unknown> {
-  return typeof value === "object"
-    && value != null
-    && Symbol.asyncIterator in value
-    && typeof value[Symbol.asyncIterator] === "function"
-}

package/util/isIterator.ts

@@ -1,6 +0,0 @@
-export function isIterator(value: unknown): value is IteratorObject<unknown, unknown, unknown> {
-  return typeof value === "object"
-    && value != null
-    && Symbol.iterator in value
-    && typeof value[Symbol.iterator] === "function"
-}

package/util/isJSONValue.ts

@@ -1,20 +0,0 @@
-import type { JSONValue } from "./JSONValue.ts"
-
-export function isJSONValue(value: unknown): value is JSONValue {
-  if (value === null) {
-    return true
-  }
-
-  if (Array.isArray(value)) {
-    return value.every((item) => isJSONValue(item))
-  }
-
-  if (typeof value === "object") {
-    if (value === null) {
-      return true
-    }
-    return Object.values(value).every((v) => isJSONValue(v))
-  }
-
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean"
-}

package/util/isPropertyKey.ts

@@ -1,3 +0,0 @@
-export function isPropertyKey(value: unknown): value is number | string | symbol {
-  return typeof value === "number" || typeof value === "string" || typeof value === "symbol"
-}

package/util/isTemplateStringsArray.ts

@@ -1,3 +0,0 @@
-export function isTemplateStringsArray(value: unknown): value is TemplateStringsArray {
-  return Array.isArray(value) && "raw" in value && Array.isArray(value.raw)
-}

package/util/jsonEquals.ts

@@ -1,41 +0,0 @@
-import type { JSONValue } from "./JSONValue"
-
-export function jsonEquals(actual: JSONValue, expected: JSONValue): boolean {
-  if (actual === expected) {
-    return true
-  }
-
-  if (typeof actual !== typeof expected) {
-    return false
-  }
-
-  if (actual === null || expected === null) {
-    return actual === expected
-  }
-
-  if (Array.isArray(actual)) {
-    if (!Array.isArray(expected)) {
-      return false
-    }
-    if (actual.length !== expected.length) {
-      return false
-    }
-    return actual.every((e, i) => jsonEquals(e, expected[i]!))
-  }
-
-  if (typeof actual === "object") {
-    if (typeof expected !== "object" || Array.isArray(expected)) {
-      return false
-    }
-    const keys = Object.keys(actual)
-    if (keys.length !== Object.keys(expected).length) {
-      return false
-    }
-    return keys.every((key) =>
-      Object.prototype.hasOwnProperty.call(expected, key)
-      && jsonEquals(actual[key]!, expected[key]!)
-    )
-  }
-
-  return actual === expected
-}

package/util/nullaryMemo.ts

@@ -1,11 +0,0 @@
-export function nullaryMemo<T>(f: () => T): () => T {
-  let initialized = false
-  let value: T | undefined = undefined
-  return () => {
-    if (!initialized) {
-      value = f()
-      initialized = true
-    }
-    return value!
-  }
-}

package/util/peekLast.ts

@@ -1,3 +0,0 @@
-export function peekLast<T>(set: Set<T>): T | undefined {
-  return [...set][set.size - 1]
-}

package/util/unimplemented.ts

@@ -1,5 +0,0 @@
-import { LiminalAssertionError } from "../LiminalAssertionError.ts"
-
-export function unimplemented(): never {
-  throw new LiminalAssertionError("Unimplemented")
-}

package/util/unreachable.ts

@@ -1,5 +0,0 @@
-import { LiminalAssertionError } from "../LiminalAssertionError.ts"
-
-export function unreachable(): never {
-  throw new LiminalAssertionError("Unreachable")
-}

package/util/unwrapDeferred.ts

@@ -1,5 +0,0 @@
-import type { DeferredOr } from "./DeferredOr.ts"
-
-export function unwrapDeferred<T>(deferred: DeferredOr<T>): T {
-  return typeof deferred === "function" ? (deferred as () => T)() : deferred
-}