@alloy-js/core 0.21.0-dev.0 → 0.21.0-dev.2

package/src/name-policy.ts

@@ -6,22 +6,41 @@ export interface NamePolicy<TElements extends string> {
    * Apply the language policy to the provided name for the provided element
    * type.
    */
-  getName(originalName: string, element: TElements): string;
+  getName(originalName: string, element: TElements | undefined): string;
   /**
    * Get a function that takes a name and applies the naming policy to it.
    */
-  for(element: TElements): NamePolicyGetter;
+  for(element: TElements | undefined): NamePolicyGetter;
 }
 
 export function createNamePolicy<T extends string>(
   namer: (name: string, elements: T) => string,
 ): NamePolicy<T> {
+  const forCache = new Map<string, NamePolicyGetter>();
+  const noopGetter = (name: string) => name;
+
   return {
     getName(name, element) {
+      if (!element) {
+        return name;
+      }
+
       return namer(name, element);
     },
+
     for(element) {
-      return (name) => namer(name, element);
+      if (!element) {
+        return noopGetter;
+      }
+
+      if (forCache.has(element)) {
+        return forCache.get(element)!;
+      }
+
+      const getter = (name: string) => namer(name, element);
+      forCache.set(element, getter);
+
+      return getter;
     },
   };
 }

package/src/pretty-string/pretty-string.test.ts

@@ -0,0 +1,47 @@
+import { expect, it } from "vitest";
+import { pret, PrettyString } from "./pretty-string.js";
+
+function expectRender(
+  pretty: PrettyString,
+  expected: {
+    toString: string;
+    toAnsi: string;
+  },
+) {
+  expect(pretty.toString()).toBe(expected.toString);
+  expect(pretty.toAnsi()).toBe(expected.toAnsi);
+}
+
+it("interpolate basic string", () => {
+  const result = pret`foo ${"bar"} baz`;
+  expectRender(result, {
+    toString: "foo bar baz",
+    toAnsi: "foo bar baz",
+  });
+});
+
+// cspell:ignore mbar
+it("interpolate pretty segment", () => {
+  const result = pret`foo ${pret.red("bar")} baz`;
+  expectRender(result, {
+    toString: "foo bar baz",
+    toAnsi: "foo \x1b[31mbar\x1b[39m baz",
+  });
+});
+
+it("interpolate another pretty string with more formatting", () => {
+  const a = pret`foo ${pret.red("bar")} baz`;
+  const result = pret`Hi, ${pret.bgGreen(a)}`;
+  expectRender(result, {
+    toString: "Hi, foo bar baz",
+    toAnsi: "Hi, \x1b[42mfoo \x1b[31mbar\x1b[39m baz\x1b[49m",
+  });
+});
+
+it("use full rgb", () => {
+  const result = pret`foo ${pret.rgb(123, 45, 67, "bar")} baz`;
+  expectRender(result, {
+    toString: "foo bar baz",
+    toAnsi: "foo \x1b[38;2;123;45;67mbar\x1b[39m baz",
+  });
+});

package/src/pretty-string/pretty-string.ts

@@ -0,0 +1,130 @@
+import { inspect } from "../inspect.js";
+
+export function pret(
+  strings: TemplateStringsArray,
+  ...keys: PrettyStringSegment[]
+): PrettyString {
+  const result: PrettyStringSegment[] = [strings[0]];
+  keys.forEach((key, i) => {
+    result.push(key);
+    result.push(strings[i + 1]);
+  });
+
+  return new PrettyString(result);
+}
+
+pret.black = (x: PrettyStringSegment) => new PrettyStringColored(x, "black");
+pret.red = (x: PrettyStringSegment) => new PrettyStringColored(x, "red");
+pret.green = (x: PrettyStringSegment) => new PrettyStringColored(x, "green");
+pret.yellow = (x: PrettyStringSegment) => new PrettyStringColored(x, "yellow");
+pret.blue = (x: PrettyStringSegment) => new PrettyStringColored(x, "blue");
+pret.magenta = (x: PrettyStringSegment) =>
+  new PrettyStringColored(x, "magenta");
+pret.cyan = (x: PrettyStringSegment) => new PrettyStringColored(x, "cyan");
+pret.white = (x: PrettyStringSegment) => new PrettyStringColored(x, "white");
+pret.gray = (x: PrettyStringSegment) => new PrettyStringColored(x, "gray");
+
+pret.bgBlack = (x: PrettyStringSegment) =>
+  new PrettyStringColored(x, "bgBlack");
+pret.bgRed = (x: PrettyStringSegment) => new PrettyStringColored(x, "bgRed");
+pret.bgGreen = (x: PrettyStringSegment) =>
+  new PrettyStringColored(x, "bgGreen");
+pret.bgYellow = (x: PrettyStringSegment) =>
+  new PrettyStringColored(x, "bgYellow");
+pret.bgBlue = (x: PrettyStringSegment) => new PrettyStringColored(x, "bgBlue");
+pret.bgMagenta = (x: PrettyStringSegment) =>
+  new PrettyStringColored(x, "bgMagenta");
+pret.bgCyan = (x: PrettyStringSegment) => new PrettyStringColored(x, "bgCyan");
+pret.bgWhite = (x: PrettyStringSegment) =>
+  new PrettyStringColored(x, "bgWhite");
+
+pret.rgb = (r: number, g: number, b: number, x: PrettyStringSegment) =>
+  new PrettyStringColored(x, { kind: "rgb", r, g, b });
+
+const ansiColors = {
+  reset: ["\x1b[0m", "\x1b[0m"],
+  bold: ["\x1b[1m", "\x1b[22m"],
+  dim: ["\x1b[2m", "\x1b[22m"],
+  italic: ["\x1b[3m", "\x1b[23m"],
+  underline: ["\x1b[4m", "\x1b[24m"],
+  inverse: ["\x1b[7m", "\x1b[27m"],
+  hidden: ["\x1b[8m", "\x1b[28m"],
+  strikethrough: ["\x1b[9m", "\x1b[29m"],
+  black: ["\x1b[30m", "\x1b[39m"],
+  red: ["\x1b[31m", "\x1b[39m"],
+  green: ["\x1b[32m", "\x1b[39m"],
+  yellow: ["\x1b[33m", "\x1b[39m"],
+  blue: ["\x1b[34m", "\x1b[39m"],
+  magenta: ["\x1b[35m", "\x1b[39m"],
+  cyan: ["\x1b[36m", "\x1b[39m"],
+  white: ["\x1b[37m", "\x1b[39m"],
+  gray: ["\x1b[90m", "\x1b[39m"],
+  bgBlack: ["\x1b[40m", "\x1b[49m"],
+  bgRed: ["\x1b[41m", "\x1b[49m"],
+  bgGreen: ["\x1b[42m", "\x1b[49m"],
+  bgYellow: ["\x1b[43m", "\x1b[49m"],
+  bgBlue: ["\x1b[44m", "\x1b[49m"],
+  bgMagenta: ["\x1b[45m", "\x1b[49m"],
+  bgCyan: ["\x1b[46m", "\x1b[49m"],
+  bgWhite: ["\x1b[47m", "\x1b[49m"],
+} as Record<string, [string, string]>;
+
+export type PrettyStringSegment = string | PrettyStringColored | PrettyString;
+
+export interface RgbColor {
+  kind: "rgb";
+  r: number;
+  g: number;
+  b: number;
+}
+
+export type ColorCodes = keyof typeof ansiColors;
+export type Color = ColorCodes | RgbColor;
+export class PrettyStringColored {
+  #value: PrettyStringSegment;
+  #color: Color;
+
+  constructor(value: PrettyStringSegment, color: Color) {
+    this.#value = value;
+    this.#color = color;
+  }
+
+  toString(): string {
+    return this.#value.toString();
+  }
+
+  toAnsi(): string {
+    if (typeof this.#color === "string") {
+      const [start, end] = ansiColors[this.#color];
+      return `${start}${typeof this.#value === "string" ? this.#value : this.#value.toAnsi()}${end}`;
+    }
+    const { r, g, b } = this.#color;
+    const start = `\x1b[38;2;${r};${g};${b}m`;
+    const end = `\x1b[39m`;
+    return `${start}${typeof this.#value === "string" ? this.#value : this.#value.toAnsi()}${end}`;
+  }
+}
+
+export class PrettyString {
+  #segments: PrettyStringSegment[];
+
+  constructor(segments: PrettyStringSegment[]) {
+    this.#segments = segments;
+  }
+
+  toString(): string {
+    return this.#segments
+      .map((s) => (typeof s === "string" ? s : s.toString()))
+      .join("");
+  }
+
+  toAnsi(): string {
+    return this.#segments
+      .map((s) => (typeof s === "string" ? s : s.toAnsi()))
+      .join("");
+  }
+
+  [inspect.custom]() {
+    return this.toAnsi();
+  }
+}

package/src/refkey.ts

@@ -192,3 +192,16 @@ export function memberRefkey(
     [RefkeySym]: true,
   };
 }
+
+export function inspectRefkey(refkey: Refkey): string {
+  const text =
+    isMemberRefkey(refkey) ?
+      `memberRefkey[${inspectRefkey(refkey.base)} -> ${inspectRefkey(refkey.member)}]`
+    : `refkey[${refkey.key}]`;
+
+  return text;
+}
+
+export function unresolvedRefkey(refkey: Refkey): string {
+  return `<Unresolved Symbol: ${inspectRefkey(refkey)}>`;
+}

package/src/symbols/output-scope.ts

@@ -254,4 +254,11 @@ export abstract class OutputScope {
       () => `${this.constructor.name} ${this.name}[${this.id}]${ownerSymbol}`,
     );
   }
+
+  toString() {
+    const ownerSymbol = this.ownerSymbol ? ` for ${this.ownerSymbol}` : "";
+    return untrack(
+      () => `${this.constructor.name} ${this.name}[${this.id}]${ownerSymbol}`,
+    );
+  }
 }

package/src/symbols/output-symbol.ts

@@ -630,6 +630,10 @@ export abstract class OutputSymbol {
   }
 
   [inspect.custom]() {
+    return this.toString();
+  }
+
+  toString() {
     return untrack(() => `${this.constructor.name} "${this.name}"[${this.id}]`);
   }
 }

package/src/tracer.ts

@@ -1,6 +1,6 @@
 import { effect, ReactiveEffectRunner } from "@vue/reactivity";
 import { untrack } from "./reactivity.js";
-import { isMemberRefkey, type Refkey } from "./refkey.js";
+import { inspectRefkey, type Refkey } from "./refkey.js";
 import { scheduler } from "./scheduler.js";
 import { type OutputScope } from "./symbols/output-scope.js";
 import type {
@@ -429,10 +429,7 @@ export function formatRefkeys(refkeys: Refkey[] | Refkey | undefined) {
 }
 
 function formatRefkey(refkey: Refkey): string {
-  const text =
-    isMemberRefkey(refkey) ?
-      `memberRefkey[${formatRefkey(refkey.base)} -> ${formatRefkey(refkey.member)}]`
-    : `refkey[${refkey.key}]`;
+  const text = inspectRefkey(refkey);
 
   return colorText(text, {
     fg: {

package/temp/api.json

@@ -7668,6 +7668,52 @@
           ],
           "extendsTokenRanges": []
         },
+        {
+          "kind": "Function",
+          "canonicalReference": "@alloy-js/core!inspectRefkey:function(1)",
+          "docComment": "",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function inspectRefkey(refkey: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Refkey",
+              "canonicalReference": "@alloy-js/core!Refkey:type"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/refkey.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 3,
+            "endIndex": 4
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "refkey",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "inspectRefkey"
+        },
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!instantiateTakenMembersTo:function(1)",
@@ -12491,7 +12537,7 @@
                 },
                 {
                   "kind": "Content",
-                  "text": "TElements"
+                  "text": "TElements | undefined"
                 },
                 {
                   "kind": "Content",
@@ -12545,7 +12591,7 @@
                 },
                 {
                   "kind": "Content",
-                  "text": "TElements"
+                  "text": "TElements | undefined"
                 },
                 {
                   "kind": "Content",
@@ -14200,6 +14246,37 @@
               "isStatic": false,
               "isProtected": false,
               "isAbstract": false
+            },
+            {
+              "kind": "Method",
+              "canonicalReference": "@alloy-js/core!OutputScope#toString:member(1)",
+              "docComment": "",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "toString(): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "string"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "releaseTag": "Public",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "toString"
             }
           ],
           "implementsTokenRanges": []
@@ -15674,6 +15751,37 @@
               "isProtected": false,
               "isAbstract": false
             },
+            {
+              "kind": "Method",
+              "canonicalReference": "@alloy-js/core!OutputSymbol#toString:member(1)",
+              "docComment": "",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "toString(): "
+                },
+                {
+                  "kind": "Content",
+                  "text": "string"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isStatic": false,
+              "returnTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "releaseTag": "Public",
+              "isProtected": false,
+              "overloadIndex": 1,
+              "parameters": [],
+              "isOptional": false,
+              "isAbstract": false,
+              "name": "toString"
+            },
             {
               "kind": "Property",
               "canonicalReference": "@alloy-js/core!OutputSymbol#type:member",
@@ -23171,6 +23279,52 @@
           ],
           "name": "traverseOutput"
         },
+        {
+          "kind": "Function",
+          "canonicalReference": "@alloy-js/core!unresolvedRefkey:function(1)",
+          "docComment": "",
+          "excerptTokens": [
+            {
+              "kind": "Content",
+              "text": "export declare function unresolvedRefkey(refkey: "
+            },
+            {
+              "kind": "Reference",
+              "text": "Refkey",
+              "canonicalReference": "@alloy-js/core!Refkey:type"
+            },
+            {
+              "kind": "Content",
+              "text": "): "
+            },
+            {
+              "kind": "Content",
+              "text": "string"
+            },
+            {
+              "kind": "Content",
+              "text": ";"
+            }
+          ],
+          "fileUrlPath": "src/refkey.ts",
+          "returnTypeTokenRange": {
+            "startIndex": 3,
+            "endIndex": 4
+          },
+          "releaseTag": "Public",
+          "overloadIndex": 1,
+          "parameters": [
+            {
+              "parameterName": "refkey",
+              "parameterTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isOptional": false
+            }
+          ],
+          "name": "unresolvedRefkey"
+        },
         {
           "kind": "Function",
           "canonicalReference": "@alloy-js/core!untrack:function(1)",