liminal 0.5.1 → 0.5.3

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/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
-}

package/util/util.ts

@@ -1,10 +0,0 @@
-export * from "./assert.ts"
-export * from "./dedent.ts"
-export * from "./DeferredOr.ts"
-export * from "./isAsyncIterator.ts"
-export * from "./isIterator.ts"
-export * from "./JSONKey.ts"
-export * from "./JSONSchemaMemo.ts"
-export * from "./JSONValue.ts"
-export * from "./unimplemented.ts"
-export * from "./unwrapDeferred.ts"