liminal 0.4.0 → 0.5.1

package/types/toJSON.ts

@@ -0,0 +1,111 @@
+import type { JSONValue } from "../util/JSONValue.ts"
+import type { JSONArrayType } from "./array.ts"
+import type { JSONBooleanType } from "./boolean.ts"
+import { type JSONConstType } from "./const.ts"
+import type { JSONEnumType } from "./enum.ts"
+import type { JSONIntegerType } from "./integer.ts"
+import type { JSONRootType } from "./JSONRootType.ts"
+import { JSONSchema$schema } from "./JSONRootType.ts"
+import type { JSONRootableType, JSONType } from "./JSONType"
+import type { JSONNullType } from "./null.ts"
+import type { JSONNumberType } from "./number.ts"
+import { _object, type JSONObjectType } from "./object.ts"
+import { type JSONStringType } from "./string.ts"
+import { type Type } from "./Type.ts"
+import { PARENT_TYPE_NAMES, typeName } from "./type_common.ts"
+import { TypeContext } from "./TypeContext.ts"
+import { TypeVisitor } from "./TypeVisitor.ts"
+import type { JSONUnionType } from "./union.ts"
+
+export function toJSON<T extends JSONValue, J extends JSONRootableType>(this: Type<T, J>): JSONRootType<J> {
+  const { $defs: { 0: root, ...$defs } } = new ToJSONState(this)
+  return {
+    $schema: JSONSchema$schema,
+    ...root,
+    $defs,
+  } as never
+}
+
+class ToJSONState extends TypeContext {
+  readonly $defs: Record<string, JSONType | undefined> = {}
+  constructor(root: Type) {
+    super(root)
+    visit(this, root)
+  }
+}
+
+const visit: TypeVisitor<ToJSONState, JSONType> = TypeVisitor({
+  hook(next, state, type) {
+    const which = typeName(type)
+    if (PARENT_TYPE_NAMES[which]) {
+      const id = state.id(type)
+      if (!(id in state.$defs)) {
+        state.$defs[id] = undefined
+        state.$defs[id] = next(state, type)
+      }
+      return type === state.root ? { $ref: "$" } : { $ref: `#/$defs/${id}` }
+    }
+    if (which === "ref") {
+      if (state.ids.has(type)) {
+        const getType = type.args?.[0] as () => Type
+        return { $ref: `#/$defs/${state.id(getType())}` }
+      }
+      state.id(type)
+      return next(state, type)
+    }
+    return next(state, type)
+  },
+  null(): JSONNullType {
+    return { type: "null" }
+  },
+  boolean(): JSONBooleanType {
+    return { type: "boolean" }
+  },
+  integer(): JSONIntegerType {
+    return { type: "integer" }
+  },
+  number(): JSONNumberType {
+    return { type: "number" }
+  },
+  string(): JSONStringType {
+    return { type: "string" }
+  },
+  const(state, _type, valueType, value): JSONConstType {
+    return {
+      ...visit(state, valueType),
+      const: value,
+    } as never
+  },
+  _array(state, _type, element): JSONArrayType {
+    return {
+      type: "array",
+      items: visit(state, element),
+    }
+  },
+  enum(_state, _type, ...values): JSONEnumType {
+    return {
+      type: "string",
+      enum: values,
+    }
+  },
+  _union(state, _type, ...members): JSONUnionType {
+    return {
+      anyOf: members.map((m) => visit(state, m)),
+    }
+  },
+  _object(state, _type, fields): JSONObjectType {
+    return {
+      type: "object",
+      properties: Object.fromEntries(
+        Array.isArray(fields)
+          ? fields.map((v, i) => [i, visit(state, v)])
+          : Object.entries(fields).map(([k, v]) => [k, visit(state, v)]),
+      ),
+      required: Object.keys(fields),
+      additionalProperties: false,
+    }
+  },
+  ref(state, _type, getType) {
+    return visit(state, getType())
+  },
+})

package/types/type_common.ts

@@ -0,0 +1,21 @@
+import { nullaryMemo } from "../util/nullaryMemo.ts"
+import * as I from "./intrinsics.ts"
+import type { Type } from "./Type.ts"
+
+export type IntrinsicTypes = typeof I
+export type IntrinsicTypeName = keyof IntrinsicTypes
+export type IntrinsicType = IntrinsicTypes[IntrinsicTypeName]
+
+export const getIntrinsicNameLookup = nullaryMemo(() =>
+  new Map(Object.entries(I).map((entry) => entry.reverse() as [IntrinsicType, keyof IntrinsicTypes]))
+)
+
+export function typeName(type: Type): IntrinsicTypeName {
+  return getIntrinsicNameLookup().get(type.declaration() as IntrinsicType)!
+}
+
+export const PARENT_TYPE_NAMES: { [K in IntrinsicTypeName]?: true } = {
+  _object: true,
+  _array: true,
+  _union: true,
+}

package/types/types_derived/option.ts

@@ -0,0 +1,10 @@
+import { type JSONNullType, null as null_ } from "../null.ts"
+import type { Type } from "../Type.ts"
+import type { NormalizeTypeLikeJ, NormalizeTypeLikeT, TypeLike } from "../TypeLike.ts"
+import { _union, type JSONUnionType, union } from "../union.ts"
+
+export function option<const X extends TypeLike>(
+  of: X,
+): Type<null | NormalizeTypeLikeT<X>, JSONUnionType<JSONNullType | NormalizeTypeLikeJ<X>>> {
+  return union(null_, of)
+}

package/types/types_derived/taggedUnion.ts

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,19 @@
+import { declareType } from "./declareType.ts"
+import type { JSONType } from "./JSONType.ts"
+import type { JSONTypeBase } from "./JSONTypeBase.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 declareType(() => _union, members)
+}
+
+export interface JSONUnionType<M extends JSONType = any> extends JSONTypeBase {
+  anyOf: Array<M>
+}

package/util/ArrayOfLength.ts

@@ -0,0 +1,5 @@
+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

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

package/util/EnsureNarrow.ts

@@ -0,0 +1,5 @@
+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

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

package/util/Expand.ts

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

package/util/Falsy.ts

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

package/util/FromEntries.ts

@@ -0,0 +1,3 @@
+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

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

package/util/JSONEntry.ts

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

package/util/JSONKey.ts

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

package/util/JSONObject.ts

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

package/util/JSONSchemaMemo.ts

@@ -0,0 +1,15 @@
+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

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

package/util/PromiseOr.ts

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

package/util/Result.ts

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

package/util/Taggable.ts

@@ -0,0 +1,18 @@
+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

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

package/util/assert.ts

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

package/util/dedent.ts

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,250 @@
+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`)
+  })
+})