Apply Prettier formatting

Author: gnidan

.github/workflows/ci.yml

@@ -1,6 +1,6 @@
 name: Continuous integration checks
 on:
-- pull_request
+  - pull_request
 
 jobs:
   run-tests:

.github/workflows/gh-pages.yml

@@ -29,10 +29,8 @@ jobs:
           folder: ./packages/web/build
           branch: gh-pages
           # default deployer
-          git-config-name: 'github-actions[bot]'
-          git-config-email: 'github-actions[bot]@users.noreply.github.com'
+          git-config-name: "github-actions[bot]"
+          git-config-email: "github-actions[bot]@users.noreply.github.com"
           # don't break preview deployments
           clean-exclude: pr-preview
           force: false
-
-

README.md

@@ -46,6 +46,7 @@ This repository contains a
 with the formal JSON Schemas defined by this project (in YAML format).
 
 This repository also contains the source materials for the following NPM packages:
+
 - **@ethdebug/format** in
   [`packages/format/`](https://github.com/ethdebug/format/tree/main/packages/format)
   distributes the formal schemas for use in TypeScript
@@ -75,6 +76,7 @@ To build and run the site locally, please ensure you have Node.js
 (LTS or better) and `yarn` installed globally.
 
 First, clone this repo and install the Node.js dependencies:
+
 ```console
 git clone https://github.com/ethdebug/format.git
 cd format
@@ -96,10 +98,12 @@ This project uses a dual-license approach:
 
 - All other code and documentation in this repository is licensed under the [MIT License](LICENSE).
 
-[^1]: See [Debugging data format -
-  Wikipedia](https://en.wikipedia.org/wiki/Debugging_data_format)
+[^1]:
+    See [Debugging data format -
+    Wikipedia](https://en.wikipedia.org/wiki/Debugging_data_format)
 
 [^2]: See [DWARF - Wikipedia](https://en.wikipedia.org/wiki/DWARF)
 
-[^3]: See [Using type predicates](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates)
-  section from TypeScript's Narrowing documentation.
+[^3]:
+    See [Using type predicates](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates)
+    section from TypeScript's Narrowing documentation.

bin/bundle-schema.ts

@@ -1,14 +1,14 @@
 import { addSchema } from "@hyperjump/json-schema/draft-2020-12";
 import { bundle as bundleSchema } from "@hyperjump/json-schema/bundle";
 import { schemas, describeSchema } from "@ethdebug/format";
-import type { JSONSchema } from "json-schema-typed/draft-2020-12"
+import type { JSONSchema } from "json-schema-typed/draft-2020-12";
 
 async function main() {
   const schema = { id: process.argv[2] }; // a bit brittle
 
   if (!schema.id) {
     console.error(
-      "Please provide a schema ID, e.g. `schema:ethdebug/format/pointer`"
+      "Please provide a schema ID, e.g. `schema:ethdebug/format/pointer`",
     );
     process.exit(1);
   }

jest.config.ts

@@ -5,7 +5,7 @@ const config: Config = {
   rootDir: "./",
   extensionsToTreatAsEsm: [".ts"],
   transform: {
-    "^.+\\.tsx?$": ['ts-jest', { useESM: true, }],
+    "^.+\\.tsx?$": ["ts-jest", { useESM: true }],
   },
   projects: ["<rootDir>/packages/*"],
 };

lerna.json

@@ -2,8 +2,6 @@
   "$schema": "node_modules/lerna/schemas/lerna-schema.json",
   "version": "independent",
   "npmClient": "yarn",
-  "packages": [
-    "packages/*"
-  ],
+  "packages": ["packages/*"],
   "rejectCycles": true
 }

packages/format/bin/generate-schema-yamls.js

@@ -26,7 +26,7 @@ const readSchemaYamls = (directory) => {
   }
 
   return schemaYamls;
-}
+};
 
 const schemaYamls = readSchemaYamls(schemasRoot);
 const rawSchemas = Object.entries(schemaYamls)
@@ -40,13 +40,13 @@ export type SchemaYamlsById = {
   [id: string]: string;
 };
 
-export const schemaYamls: SchemaYamlsById = ${
-  JSON.stringify(schemaYamls, undefined, 2)
-};
+export const schemaYamls: SchemaYamlsById = ${JSON.stringify(
+  schemaYamls,
+  undefined,
+  2,
+)};
 
-const rawSchemas = ${
-  JSON.stringify(rawSchemas, undefined, 2)
-} as const;
+const rawSchemas = ${JSON.stringify(rawSchemas, undefined, 2)} as const;
 
 export type Schema<Id extends keyof typeof rawSchemas> =
   (typeof rawSchemas)[Id];

packages/format/src/describe.ts

@@ -2,16 +2,16 @@ import * as YAML from "yaml";
 
 import { schemaYamls } from "./schemas/yamls";
 
-import type { JSONSchema as JSONSchemaTyped } from "json-schema-typed/draft-2020-12"
+import type { JSONSchema as JSONSchemaTyped } from "json-schema-typed/draft-2020-12";
 
 export type JSONSchema = Exclude<JSONSchemaTyped, boolean>;
 
 export interface DescribeSchemaOptions<
-  S extends SchemaReference = SchemaReference
+  S extends SchemaReference = SchemaReference,
 > {
   schema: S;
   pointer?: SchemaPointer;
-};
+}
 
 export interface SchemaInfo {
   id?: string; // root ID only
@@ -23,46 +23,42 @@ export interface SchemaInfo {
 
 const parseOptions = {
   // merge keys were removed from YAML 1.2 spec but used by these schemas
-  merge: true
+  merge: true,
 };
 
 export function describeSchema({
   schema,
-  pointer
+  pointer,
 }: DescribeSchemaOptions): SchemaInfo {
   if (typeof pointer === "string" && !pointer.startsWith("#")) {
     throw new Error("`pointer` option must start with '#'");
   }
 
-  const pointerOptions = pointer
-    ? { pointer }
-    : {};
+  const pointerOptions = pointer ? { pointer } : {};
 
   if (referencesId(schema)) {
     return describeSchemaById({
-      schema: typeof schema === "object"
-        ? schema
-        : { id: schema },
-      ...pointerOptions
+      schema: typeof schema === "object" ? schema : { id: schema },
+      ...pointerOptions,
     });
   }
 
   if (referencesYaml(schema)) {
     return describeSchemaByYaml({
       schema,
-      ...pointerOptions
+      ...pointerOptions,
     });
   }
 
   return describeSchemaByObject({
     schema,
-    ...pointerOptions
+    ...pointerOptions,
   });
 }
 
 function describeSchemaById({
   schema: { id: referencedId },
-  pointer: relativePointer
+  pointer: relativePointer,
 }: DescribeSchemaOptions<SchemaById>): SchemaInfo {
   // we need to handle the case where the schema is referenced by an ID
   // with a pointer specified, possibly with a separate `pointer` field too
@@ -72,7 +68,7 @@ function describeSchemaById({
     ? joinSchemaPointers([`#${rawReferencedPointer}`, relativePointer])
     : relativePointer;
 
-  const rootYaml = schemaYamls[id]
+  const rootYaml = schemaYamls[id];
   if (!rootYaml) {
     throw new Error(`Unknown schema with $id "${id}"`);
   }
@@ -87,13 +83,13 @@ function describeSchemaById({
     ...(pointer ? { pointer } : {}),
     yaml,
     schema,
-    rootSchema
-  }
+    rootSchema,
+  };
 }
 
 function describeSchemaByYaml({
   schema: { yaml: referencedYaml },
-  pointer
+  pointer,
 }: DescribeSchemaOptions<SchemaByYaml>): SchemaInfo {
   const yaml = pointToYaml(referencedYaml, pointer);
 
@@ -108,21 +104,21 @@ function describeSchemaByYaml({
       ...(pointer ? { pointer } : {}),
       yaml,
       schema,
-      rootSchema
-    }
+      rootSchema,
+    };
   } else {
     return {
       ...(pointer ? { pointer } : {}),
       yaml,
       schema,
-      rootSchema
-    }
+      rootSchema,
+    };
   }
 }
 
 function describeSchemaByObject({
   schema: rootSchema,
-  pointer
+  pointer,
 }: DescribeSchemaOptions<object>): SchemaInfo {
   const rootYaml = YAML.stringify(rootSchema);
 
@@ -138,24 +134,24 @@ function describeSchemaByObject({
       ...(pointer ? { pointer } : {}),
       yaml,
       schema,
-      rootSchema
-    }
+      rootSchema,
+    };
   } else {
     return {
       ...(pointer ? { pointer } : {}),
       yaml,
       schema,
-      rootSchema
-    }
+      rootSchema,
+    };
   }
 }
 
 function joinSchemaPointers(
-  pointers: (SchemaPointer | undefined)[]
+  pointers: (SchemaPointer | undefined)[],
 ): SchemaPointer | undefined {
   const joined = pointers
     .filter((pointer): pointer is SchemaPointer => typeof pointer === "string")
-    .map(pointer => pointer.slice(1))
+    .map((pointer) => pointer.slice(1))
     .join("");
 
   if (joined.length === 0) {
@@ -165,10 +161,7 @@ function joinSchemaPointers(
   return `#${joined}`;
 }
 
-function pointToYaml(
-  yaml: string,
-  pointer?: SchemaPointer
-): string {
+function pointToYaml(yaml: string, pointer?: SchemaPointer): string {
   if (!pointer) {
     return yaml;
   }
@@ -192,9 +185,8 @@ type Impossible<K extends keyof any> = {
   [P in K]: never;
 };
 
-type NoExtraProperties<T, U extends T = T> =
-  & U
-  & Impossible<Exclude<keyof U, keyof T>>;
+type NoExtraProperties<T, U extends T = T> = U &
+  Impossible<Exclude<keyof U, keyof T>>;
 
 export type SchemaPointer = `#${string}`;
 
@@ -215,7 +207,7 @@ export type SchemaByYaml = NoExtraProperties<{
 }>;
 
 export function referencesId(
-  schema: SchemaReference
+  schema: SchemaReference,
 ): schema is SchemaId | SchemaById {
   return (
     typeof schema === "string" ||
@@ -224,8 +216,11 @@ export function referencesId(
 }
 
 export function referencesYaml(
-  schema: SchemaReference
+  schema: SchemaReference,
 ): schema is SchemaByYaml {
-  return typeof schema === "object" &&
-    Object.keys(schema).length === 1 && "yaml" in schema;
+  return (
+    typeof schema === "object" &&
+    Object.keys(schema).length === 1 &&
+    "yaml" in schema
+  );
 }