@milaboratories/pl-model-common 1.24.3 → 1.24.4

package/src/flags/flag_utils.test.ts

@@ -1,45 +1,50 @@
-import { describe, it, expect } from 'vitest';
-import { RuntimeCapabilities, IncompatibleFlagsError } from './flag_utils';
-import type { BlockCodeFeatureFlags } from './block_flags';
+import { describe, it, expect } from "vitest";
+import { RuntimeCapabilities, IncompatibleFlagsError } from "./flag_utils";
+import type { BlockCodeFeatureFlags } from "./block_flags";
 
-describe('RuntimeCapabilities', () => {
-  describe('addSupportedRequirement', () => {
-    it('should add a supported requirement with default value true', () => {
+describe("RuntimeCapabilities", () => {
+  describe("addSupportedRequirement", () => {
+    it("should add a supported requirement with default value true", () => {
       const capabilities = new RuntimeCapabilities();
-      capabilities.addSupportedRequirement('requiresModelAPIVersion');
+      capabilities.addSupportedRequirement("requiresModelAPIVersion");
       const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: true };
       expect(capabilities.checkCompatibility(blockFlags)).toBe(true);
     });
 
-    it('should add a supported requirement with a specific boolean value', () => {
-        const capabilities = new RuntimeCapabilities();
-        capabilities.addSupportedRequirement('requiresModelAPIVersion', false);
-        const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: false };
-        expect(capabilities.checkCompatibility(blockFlags)).toBe(true);
-        const blockFlags2: BlockCodeFeatureFlags = { requiresModelAPIVersion: true };
-        expect(capabilities.checkCompatibility(blockFlags2)).toBe(false);
+    it("should add a supported requirement with a specific boolean value", () => {
+      const capabilities = new RuntimeCapabilities();
+      capabilities.addSupportedRequirement("requiresModelAPIVersion", false);
+      const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: false };
+      expect(capabilities.checkCompatibility(blockFlags)).toBe(true);
+      const blockFlags2: BlockCodeFeatureFlags = { requiresModelAPIVersion: true };
+      expect(capabilities.checkCompatibility(blockFlags2)).toBe(false);
     });
 
-    it('should add a supported requirement with a specific number value', () => {
-        const capabilities = new RuntimeCapabilities();
-        capabilities.addSupportedRequirement('requiresModelAPIVersion', 2);
-        const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: 2 };
-        expect(capabilities.checkCompatibility(blockFlags)).toBe(true);
-        const blockFlags2: BlockCodeFeatureFlags = { requiresModelAPIVersion: 3 };
-        expect(capabilities.checkCompatibility(blockFlags2)).toBe(false);
+    it("should add a supported requirement with a specific number value", () => {
+      const capabilities = new RuntimeCapabilities();
+      capabilities.addSupportedRequirement("requiresModelAPIVersion", 2);
+      const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: 2 };
+      expect(capabilities.checkCompatibility(blockFlags)).toBe(true);
+      const blockFlags2: BlockCodeFeatureFlags = { requiresModelAPIVersion: 3 };
+      expect(capabilities.checkCompatibility(blockFlags2)).toBe(false);
     });
 
-    it('should allow chaining', () => {
-        const capabilities = new RuntimeCapabilities();
-        capabilities.addSupportedRequirement('requiresModelAPIVersion').addSupportedRequirement('requiresUIAPIVersion');
-        const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: true, requiresUIAPIVersion: true };
-        expect(capabilities.checkCompatibility(blockFlags)).toBe(true);
+    it("should allow chaining", () => {
+      const capabilities = new RuntimeCapabilities();
+      capabilities
+        .addSupportedRequirement("requiresModelAPIVersion")
+        .addSupportedRequirement("requiresUIAPIVersion");
+      const blockFlags: BlockCodeFeatureFlags = {
+        requiresModelAPIVersion: true,
+        requiresUIAPIVersion: true,
+      };
+      expect(capabilities.checkCompatibility(blockFlags)).toBe(true);
     });
 
-    it('should support multiple values for the same requirement', () => {
+    it("should support multiple values for the same requirement", () => {
       const capabilities = new RuntimeCapabilities();
-      capabilities.addSupportedRequirement('requiresModelAPIVersion', 2);
-      capabilities.addSupportedRequirement('requiresModelAPIVersion', 3);
+      capabilities.addSupportedRequirement("requiresModelAPIVersion", 2);
+      capabilities.addSupportedRequirement("requiresModelAPIVersion", 3);
       const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: 2 };
       expect(capabilities.checkCompatibility(blockFlags)).toBe(true);
       const blockFlags2: BlockCodeFeatureFlags = { requiresModelAPIVersion: 3 };
@@ -49,48 +54,55 @@ describe('RuntimeCapabilities', () => {
     });
   });
 
-  describe('checkCompatibility and getIncompatibleFlags', () => {
-    it('should return compatible for undefined flags', () => {
+  describe("checkCompatibility and getIncompatibleFlags", () => {
+    it("should return compatible for undefined flags", () => {
       const capabilities = new RuntimeCapabilities();
       expect(capabilities.checkCompatibility(undefined)).toBe(true);
       expect(capabilities.getIncompatibleFlags(undefined)).toBeUndefined();
     });
 
-    it('should return compatible for empty flags object', () => {
+    it("should return compatible for empty flags object", () => {
       const capabilities = new RuntimeCapabilities();
       expect(capabilities.checkCompatibility({})).toBe(true);
       expect(capabilities.getIncompatibleFlags({})).toBeUndefined();
     });
 
-    it('should be compatible if requirements are met', () => {
+    it("should be compatible if requirements are met", () => {
       const capabilities = new RuntimeCapabilities()
-        .addSupportedRequirement('requiresModelAPIVersion')
-        .addSupportedRequirement('requiresUIAPIVersion', 2);
-      const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: true, requiresUIAPIVersion: 2, supportsSomething: true };
+        .addSupportedRequirement("requiresModelAPIVersion")
+        .addSupportedRequirement("requiresUIAPIVersion", 2);
+      const blockFlags: BlockCodeFeatureFlags = {
+        requiresModelAPIVersion: true,
+        requiresUIAPIVersion: 2,
+        supportsSomething: true,
+      };
       expect(capabilities.checkCompatibility(blockFlags)).toBe(true);
       expect(capabilities.getIncompatibleFlags(blockFlags)).toBeUndefined();
     });
 
-    it('should be incompatible if a requirement value is not met', () => {
-        const capabilities = new RuntimeCapabilities().addSupportedRequirement('requiresModelAPIVersion', 2);
-        const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: 3 };
-        expect(capabilities.checkCompatibility(blockFlags)).toBe(false);
-        const incompatible = capabilities.getIncompatibleFlags(blockFlags);
-        expect(incompatible).toEqual(new Map([['requiresModelAPIVersion', 3]]));
+    it("should be incompatible if a requirement value is not met", () => {
+      const capabilities = new RuntimeCapabilities().addSupportedRequirement(
+        "requiresModelAPIVersion",
+        2,
+      );
+      const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: 3 };
+      expect(capabilities.checkCompatibility(blockFlags)).toBe(false);
+      const incompatible = capabilities.getIncompatibleFlags(blockFlags);
+      expect(incompatible).toEqual(new Map([["requiresModelAPIVersion", 3]]));
     });
 
-    it('should be incompatible if a requirement is not specified in runtime capabilities', () => {
+    it("should be incompatible if a requirement is not specified in runtime capabilities", () => {
       const capabilities = new RuntimeCapabilities();
       const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: true };
       expect(capabilities.checkCompatibility(blockFlags)).toBe(false);
       const incompatible = capabilities.getIncompatibleFlags(blockFlags);
-      expect(incompatible).toEqual(new Map([['requiresModelAPIVersion', true]]));
+      expect(incompatible).toEqual(new Map([["requiresModelAPIVersion", true]]));
     });
 
-    it('should correctly identify multiple incompatible flags', () => {
+    it("should correctly identify multiple incompatible flags", () => {
       const capabilities = new RuntimeCapabilities()
-        .addSupportedRequirement('requiresModelAPIVersion', true)
-        .addSupportedRequirement('requiresUIAPIVersion', 2);
+        .addSupportedRequirement("requiresModelAPIVersion", true)
+        .addSupportedRequirement("requiresUIAPIVersion", 2);
 
       const blockFlags: BlockCodeFeatureFlags = {
         requiresModelAPIVersion: false,
@@ -100,51 +112,60 @@ describe('RuntimeCapabilities', () => {
 
       expect(capabilities.checkCompatibility(blockFlags)).toBe(false);
       const incompatible = capabilities.getIncompatibleFlags(blockFlags);
-      expect(incompatible).toEqual(new Map<string, number | boolean>([
-        ['requiresModelAPIVersion', false],
-        ['requiresUIAPIVersion', 3],
-        ['requiresSomethingElse', true],
-      ]));
+      expect(incompatible).toEqual(
+        new Map<string, number | boolean>([
+          ["requiresModelAPIVersion", false],
+          ["requiresUIAPIVersion", 3],
+          ["requiresSomethingElse", true],
+        ]),
+      );
     });
 
-    it('should ignore non-requirement flags', () => {
-        const capabilities = new RuntimeCapabilities();
-        const blockFlags: BlockCodeFeatureFlags = { supportsSomething: true };
-        expect(capabilities.checkCompatibility(blockFlags)).toBe(true);
-        expect(capabilities.getIncompatibleFlags(blockFlags)).toBeUndefined();
+    it("should ignore non-requirement flags", () => {
+      const capabilities = new RuntimeCapabilities();
+      const blockFlags: BlockCodeFeatureFlags = { supportsSomething: true };
+      expect(capabilities.checkCompatibility(blockFlags)).toBe(true);
+      expect(capabilities.getIncompatibleFlags(blockFlags)).toBeUndefined();
     });
 
-    it('should ignore undefined requirement flags in block', () => {
-        const capabilities = new RuntimeCapabilities();
-        const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: undefined };
-        expect(capabilities.checkCompatibility(blockFlags)).toBe(true);
-        expect(capabilities.getIncompatibleFlags(blockFlags)).toBeUndefined();
+    it("should ignore undefined requirement flags in block", () => {
+      const capabilities = new RuntimeCapabilities();
+      const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: undefined };
+      expect(capabilities.checkCompatibility(blockFlags)).toBe(true);
+      expect(capabilities.getIncompatibleFlags(blockFlags)).toBeUndefined();
     });
 
-    it('should be incompatible if a requirement is not defined in capabilities', () => {
+    it("should be incompatible if a requirement is not defined in capabilities", () => {
       const capabilities = new RuntimeCapabilities(); // No requirements added.
       const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: 1 };
       expect(capabilities.checkCompatibility(blockFlags)).toBe(false);
       const incompatible = capabilities.getIncompatibleFlags(blockFlags);
-      expect(incompatible).toEqual(new Map([['requiresModelAPIVersion', 1]]));
+      expect(incompatible).toEqual(new Map([["requiresModelAPIVersion", 1]]));
     });
   });
 
-  describe('throwIfIncompatible', () => {
-    it('should not throw if flags are compatible', () => {
-      const capabilities = new RuntimeCapabilities().addSupportedRequirement('requiresModelAPIVersion');
+  describe("throwIfIncompatible", () => {
+    it("should not throw if flags are compatible", () => {
+      const capabilities = new RuntimeCapabilities().addSupportedRequirement(
+        "requiresModelAPIVersion",
+      );
       const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: true };
       expect(() => capabilities.throwIfIncompatible(blockFlags)).not.toThrow();
     });
 
-    it('should throw IncompatibleFlagsError if flags are incompatible', () => {
-      const capabilities = new RuntimeCapabilities().addSupportedRequirement('requiresModelAPIVersion');
+    it("should throw IncompatibleFlagsError if flags are incompatible", () => {
+      const capabilities = new RuntimeCapabilities().addSupportedRequirement(
+        "requiresModelAPIVersion",
+      );
       const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: false };
       expect(() => capabilities.throwIfIncompatible(blockFlags)).toThrow(IncompatibleFlagsError);
     });
 
-    it('should throw with an error containing incompatible flags', () => {
-      const capabilities = new RuntimeCapabilities().addSupportedRequirement('requiresModelAPIVersion', 1);
+    it("should throw with an error containing incompatible flags", () => {
+      const capabilities = new RuntimeCapabilities().addSupportedRequirement(
+        "requiresModelAPIVersion",
+        1,
+      );
       const blockFlags: BlockCodeFeatureFlags = { requiresModelAPIVersion: 2 };
       try {
         capabilities.throwIfIncompatible(blockFlags);
@@ -153,8 +174,8 @@ describe('RuntimeCapabilities', () => {
       } catch (e) {
         expect(e).toBeInstanceOf(IncompatibleFlagsError);
         if (e instanceof IncompatibleFlagsError) {
-          expect(e.incompatibleFlags).toEqual(new Map([['requiresModelAPIVersion', 2]]));
-          expect(e.message).toContain('requiresModelAPIVersion: 2');
+          expect(e.incompatibleFlags).toEqual(new Map([["requiresModelAPIVersion", 2]]));
+          expect(e.message).toContain("requiresModelAPIVersion: 2");
         }
       }
     });

package/src/flags/flag_utils.ts

@@ -1,60 +1,82 @@
-import type { BlockCodeFeatureFlags, BlockCodeKnownFeatureFlags } from './block_flags';
-import type { FilterKeysByPrefix } from './type_utils';
+import type { BlockCodeFeatureFlags, BlockCodeKnownFeatureFlags } from "./block_flags";
+import type { FilterKeysByPrefix } from "./type_utils";
 
-export function checkBlockFlag(flags: BlockCodeFeatureFlags | undefined, flag: keyof BlockCodeKnownFeatureFlags, flagValue: boolean | number = true): boolean {
+export function checkBlockFlag(
+  flags: BlockCodeFeatureFlags | undefined,
+  flag: keyof BlockCodeKnownFeatureFlags,
+  flagValue: boolean | number = true,
+): boolean {
   if (flags === undefined) return false;
   return flags[flag] === flagValue;
 }
 
 /**
-   * Extracts all requirements from the feature flags.
-   * @param flags - The feature flags.
-   * @returns A set of requirements.
-   */
-export function extractAllRequirements(flags: BlockCodeFeatureFlags | undefined): Set<`requires${string}`> {
+ * Extracts all requirements from the feature flags.
+ * @param flags - The feature flags.
+ * @returns A set of requirements.
+ */
+export function extractAllRequirements(
+  flags: BlockCodeFeatureFlags | undefined,
+): Set<`requires${string}`> {
   if (flags === undefined) return new Set();
-  return new Set(Object.entries(flags)
-    .filter(([key, value]) => key.startsWith('requires') && value === true)
-    .map(([key]) => key as `requires${string}`));
+  return new Set(
+    Object.entries(flags)
+      .filter(([key, value]) => key.startsWith("requires") && value === true)
+      .map(([key]) => key as `requires${string}`),
+  );
 }
 
 /**
-   * Extracts all supports from the feature flags.
-   * @param flags - The feature flags.
-   * @returns A set of supports.
-   */
-export function extractAllSupports(flags: BlockCodeFeatureFlags | undefined): Set<`supports${string}`> {
+ * Extracts all supports from the feature flags.
+ * @param flags - The feature flags.
+ * @returns A set of supports.
+ */
+export function extractAllSupports(
+  flags: BlockCodeFeatureFlags | undefined,
+): Set<`supports${string}`> {
   if (flags === undefined) return new Set();
-  return new Set(Object.entries(flags)
-    .filter(([key, value]) => key.startsWith('supports') && value === true)
-    .map(([key]) => key as `supports${string}`));
+  return new Set(
+    Object.entries(flags)
+      .filter(([key, value]) => key.startsWith("supports") && value === true)
+      .map(([key]) => key as `supports${string}`),
+  );
 }
 
 export class IncompatibleFlagsError extends Error {
-  name = 'IncompatibleFlagsError';
+  name = "IncompatibleFlagsError";
   constructor(public readonly incompatibleFlags: Map<`requires${string}`, number | boolean>) {
-    super(`Some of the block requirements are not supported by the runtime: ${Array.from(incompatibleFlags.entries()).map(([key, value]) => `${key}: ${value}`).join(', ')}`);
+    super(
+      `Some of the block requirements are not supported by the runtime: ${Array.from(
+        incompatibleFlags.entries(),
+      )
+        .map(([key, value]) => `${key}: ${value}`)
+        .join(", ")}`,
+    );
   }
 }
 
 /**
-   * A type that represents a supported requirement.
-   * @remarks
-   * This type is used to represent a supported requirement.
-   * It is a subtype of `BlockCodeKnownFeatureFlags` and is used to represent a supported requirement.
-   * It is used to represent a supported requirement.
-   */
-export type SupportedRequirement = FilterKeysByPrefix<BlockCodeKnownFeatureFlags, 'requires'>;
+ * A type that represents a supported requirement.
+ * @remarks
+ * This type is used to represent a supported requirement.
+ * It is a subtype of `BlockCodeKnownFeatureFlags` and is used to represent a supported requirement.
+ * It is used to represent a supported requirement.
+ */
+export type SupportedRequirement = FilterKeysByPrefix<BlockCodeKnownFeatureFlags, "requires">;
 
 export class RuntimeCapabilities {
-  private readonly supportedRequirements: Map<`requires${string}`, Set<number | boolean>> = new Map();
+  private readonly supportedRequirements: Map<`requires${string}`, Set<number | boolean>> =
+    new Map();
 
   /**
-     * Adds a supported requirement to the runtime capabilities.
-     * @param requirement - The requirement.
-     * @param value - The value of the requirement. If not provided, defaults to true.
-     */
-  public addSupportedRequirement(requirement: SupportedRequirement, value: number | boolean = true): this {
+   * Adds a supported requirement to the runtime capabilities.
+   * @param requirement - The requirement.
+   * @param value - The value of the requirement. If not provided, defaults to true.
+   */
+  public addSupportedRequirement(
+    requirement: SupportedRequirement,
+    value: number | boolean = true,
+  ): this {
     if (!this.supportedRequirements.has(requirement)) {
       this.supportedRequirements.set(requirement, new Set());
     }
@@ -63,15 +85,17 @@ export class RuntimeCapabilities {
   }
 
   /**
-     * Returns a map of incompatible flags. If the block flags are compatible, returns undefined.
-     * @param blockFlags - The block flags.
-     * @returns A map of incompatible flags, or undefined if the block flags are compatible.
-     */
-  public getIncompatibleFlags(blockFlags: BlockCodeFeatureFlags | undefined): Map<`requires${string}`, number | boolean> | undefined {
+   * Returns a map of incompatible flags. If the block flags are compatible, returns undefined.
+   * @param blockFlags - The block flags.
+   * @returns A map of incompatible flags, or undefined if the block flags are compatible.
+   */
+  public getIncompatibleFlags(
+    blockFlags: BlockCodeFeatureFlags | undefined,
+  ): Map<`requires${string}`, number | boolean> | undefined {
     if (blockFlags === undefined) return undefined;
     const incompatibleFlags = new Map<`requires${string}`, number | boolean>();
     for (const [key, value] of Object.entries(blockFlags)) {
-      if (key.startsWith('requires')) {
+      if (key.startsWith("requires")) {
         if (value === undefined) continue;
         const supportedValues = this.supportedRequirements.get(key as `requires${string}`);
         if (supportedValues === undefined || !supportedValues.has(value as number | boolean)) {
@@ -83,22 +107,21 @@ export class RuntimeCapabilities {
   }
 
   /**
-     * Checks if the block flags are compatible with the runtime capabilities.
-     * @param blockFlags - The block flags.
-     * @returns True if the block flags are compatible, false otherwise.
-     */
+   * Checks if the block flags are compatible with the runtime capabilities.
+   * @param blockFlags - The block flags.
+   * @returns True if the block flags are compatible, false otherwise.
+   */
   public checkCompatibility(blockFlags: BlockCodeFeatureFlags | undefined): boolean {
     return this.getIncompatibleFlags(blockFlags) === undefined;
   }
 
   /**
-     * Throws an error if the block flags are incompatible with the runtime capabilities.
-     * @param blockFlags - The block flags.
-     * @throws IncompatibleFlagsError if the block flags are incompatible with the runtime capabilities.
-     */
+   * Throws an error if the block flags are incompatible with the runtime capabilities.
+   * @param blockFlags - The block flags.
+   * @throws IncompatibleFlagsError if the block flags are incompatible with the runtime capabilities.
+   */
   public throwIfIncompatible(blockFlags: BlockCodeFeatureFlags | undefined) {
     const incompatibleFlags = this.getIncompatibleFlags(blockFlags);
-    if (incompatibleFlags !== undefined)
-      throw new IncompatibleFlagsError(incompatibleFlags);
+    if (incompatibleFlags !== undefined) throw new IncompatibleFlagsError(incompatibleFlags);
   }
 }

package/src/flags/index.ts

@@ -1,3 +1,3 @@
-export * from './block_flags';
-export * from './flag_utils';
-export * from './type_utils';
+export * from "./block_flags";
+export * from "./flag_utils";
+export * from "./type_utils";

package/src/flags/type_utils.ts

@@ -10,17 +10,17 @@ export type FilterKeysByPrefix<T, P extends string> = keyof {
  * Helper to assert that two types are equal. This will cause a compile-time error if they are not.
  * We use this to ensure all feature flags are accounted for in the arrays below.
  */
-export type AssertKeysEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2
-  ? unknown
-  : { error: 'Feature flag definitions are out of sync'; expected: T; actual: U };
+export type AssertKeysEqual<T, U> =
+  (<V>() => V extends T ? 1 : 2) extends <V>() => V extends U ? 1 : 2
+    ? unknown
+    : { error: "Feature flag definitions are out of sync"; expected: T; actual: U };
 
 /**
  * Checks if two types are exactly equal.
  * Returns 'true' if they are, 'false' otherwise.
  */
-export type Is<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2
-  ? true
-  : false;
+export type Is<T, U> =
+  (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
 
 /**
  * Checks if T is a subtype of U.
@@ -37,7 +37,10 @@ export type Assert<T extends true> = T;
 /**
  * Helper to create a union type of two array value types.
  */
-export type ArrayTypeUnion<T extends readonly any[], U extends readonly any[]> = T[number] extends never
+export type ArrayTypeUnion<
+  T extends readonly any[],
+  U extends readonly any[],
+> = T[number] extends never
   ? U[number]
   : U[number] extends never
     ? T[number]

package/src/httpAuth.ts

@@ -2,14 +2,13 @@
 
 export function parseHttpAuth(input: string): HttpAuth {
   const match = /(?<scheme>.*?) (?<parameters>.*)/.exec(input);
-  if (match?.groups?.scheme === 'Basic') {
-    const credentialsMatch = /(?<username>.*?):(?<password>.*)/
-      .exec(atob(match.groups.parameters));
+  if (match?.groups?.scheme === "Basic") {
+    const credentialsMatch = /(?<username>.*?):(?<password>.*)/.exec(atob(match.groups.parameters));
     if (!credentialsMatch?.groups) {
       throw new Error(`Malformed credentials.`);
     }
     return {
-      scheme: 'Basic',
+      scheme: "Basic",
       username: credentialsMatch.groups.username,
       password: credentialsMatch.groups.password,
     };
@@ -18,7 +17,7 @@ export function parseHttpAuth(input: string): HttpAuth {
 }
 
 export function serializeHttpAuth(input: HttpAuth): string {
-  if (input.scheme === 'Basic') {
+  if (input.scheme === "Basic") {
     return `Basic ${btoa(`${input.username}:${input.password}`)}`;
   }
   throw new Error(`Unsupported auth scheme: ${input.scheme as string}.`);
@@ -27,7 +26,7 @@ export function serializeHttpAuth(input: HttpAuth): string {
 export type HttpAuth = BasicHttpAuth;
 
 export interface BasicHttpAuth {
-  scheme: 'Basic';
+  scheme: "Basic";
   username: string;
   password: string;
 }

package/src/index.ts

@@ -1,19 +1,19 @@
-export * from './author_marker';
-export * from './block_state';
-export * from './bmodel';
-export * from './branding';
-export * from './common_types';
-export * from './driver_kit';
-export * from './drivers';
-export * from './errors';
-export * from './flags';
-export * from './json';
-export * from './navigation';
-export * from './plid';
-export * from './pool';
-export * from './ref';
-export * from './utag';
-export * from './value_or_error';
-export * from './base64';
-export * from './util';
-export * from './httpAuth';
+export * from "./author_marker";
+export * from "./block_state";
+export * from "./bmodel";
+export * from "./branding";
+export * from "./common_types";
+export * from "./driver_kit";
+export * from "./drivers";
+export * from "./errors";
+export * from "./flags";
+export * from "./json";
+export * from "./navigation";
+export * from "./plid";
+export * from "./pool";
+export * from "./ref";
+export * from "./utag";
+export * from "./value_or_error";
+export * from "./base64";
+export * from "./util";
+export * from "./httpAuth";

package/src/json.ts

@@ -1,4 +1,4 @@
-import canonicalize from 'canonicalize';
+import canonicalize from "canonicalize";
 
 type JsonPrimitive = string | number | boolean | null;
 
@@ -13,18 +13,26 @@ export type JsonSerializable =
 // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
 type NotAssignableToJson = bigint | symbol | Function;
 
-export type JsonCompatible<T> = unknown extends T ? unknown
-  : [T] extends [JsonValue] ? T
-      : [T] extends [NotAssignableToJson] ? never
-          : {
-              [P in keyof T]: [Exclude<T[P], undefined>] extends [JsonValue] ? T[P]
-                : [Exclude<T[P], undefined>] extends [NotAssignableToJson] ? never
-                    : JsonCompatible<T[P]>;
-            };
-
-export type StringifiedJson<T = unknown> = JsonCompatible<T> extends never ? never : string & {
-  __json_stringified: T;
-};
+export type JsonCompatible<T> = unknown extends T
+  ? unknown
+  : [T] extends [JsonValue]
+    ? T
+    : [T] extends [NotAssignableToJson]
+      ? never
+      : {
+          [P in keyof T]: [Exclude<T[P], undefined>] extends [JsonValue]
+            ? T[P]
+            : [Exclude<T[P], undefined>] extends [NotAssignableToJson]
+              ? never
+              : JsonCompatible<T[P]>;
+        };
+
+export type StringifiedJson<T = unknown> =
+  JsonCompatible<T> extends never
+    ? never
+    : string & {
+        __json_stringified: T;
+      };
 
 export function stringifyJson<T>(value: JsonCompatible<T>): StringifiedJson<T>;
 export function stringifyJson<T extends JsonSerializable>(value: T): string;
@@ -32,9 +40,12 @@ export function stringifyJson(value: unknown): string {
   return JSON.stringify(value);
 }
 
-export type CanonicalizedJson<T = unknown> = JsonCompatible<T> extends never ? never : string & {
-  __json_canonicalized: T;
-};
+export type CanonicalizedJson<T = unknown> =
+  JsonCompatible<T> extends never
+    ? never
+    : string & {
+        __json_canonicalized: T;
+      };
 
 export function canonicalizeJson<T>(value: JsonCompatible<T>): CanonicalizedJson<T>;
 export function canonicalizeJson<T extends JsonSerializable>(value: T): string;
@@ -47,5 +58,5 @@ export function parseJson<T>(value: StringifiedJson<T> | CanonicalizedJson<T>):
 }
 
 export function bigintReplacer(_key: string, value: unknown): unknown {
-  return typeof value === 'bigint' ? value.toString() : value;
+  return typeof value === "bigint" ? value.toString() : value;
 }

package/src/navigation.ts

@@ -6,7 +6,7 @@ export type BlockSection = BlockSectionLink | BlockSectionDelimiter;
 export type BlockSectionLink = {
   /** Potentially there may be multiple section types, i.e. for "+" rows and for
    * sections directly opening html from the outputs. */
-  readonly type: 'link';
+  readonly type: "link";
 
   /** Internal block section identifier */
   readonly href: `/${string}`;
@@ -24,11 +24,11 @@ export type BlockSectionLink = {
 /** Different variants for link section appearance */
 export type BlockSectionLinkAppearance =
   /** Shows a section of type `link` with a `+` icon and a certain specific style */
-  'add-section';
+  "add-section";
 
 /** Create a horizontal line between sections */
 export type BlockSectionDelimiter = {
-  readonly type: 'delimiter';
+  readonly type: "delimiter";
 };
 
 /**
@@ -39,4 +39,4 @@ export type NavigationState<Href extends `/${string}` = `/${string}`> = {
   readonly href: Href;
 };
 
-export const DefaultNavigationState: NavigationState = { href: '/' };
+export const DefaultNavigationState: NavigationState = { href: "/" };