@appweaver/client 1.3.0 → 1.4.0

package/cjs/utils/enum-util.js

@@ -1,179 +1,59 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hoistSharedEnums = hoistSharedEnums;
-const constants_1 = require("../constants");
+exports.rewriteEnumsAsObjects = rewriteEnumsAsObjects;
 /**
- * Hoists the inline enums a schema repeats across its definitions into shared definitions
- * of their own, replacing every occurrence with a reference to the hoisted definition.
- *
- * An Appweaver schema declares the same enum inline over and over, once per property that
- * accepts it, and each of them would otherwise become an enum of its own in the generated
- * types (i.e. a separate `asc | desc` enum for every sortable field of every resource).
- *
- * Only enums that are byte for byte identical are hoisted, so no property loses its
- * description, example or nullability along the way. The hoisted definition is named after
- * {@link SHARED_ENUM_NAMES} when its values are well known, and otherwise after the part
- * the declaring definitions have in common followed by the property name (i.e. `PostCreate`
- * and `PostSingle` declaring `status` give `PostStatus`). Enums whose name cannot be
- * resolved, or whose name is already taken, are left inline.
- *
- * The given schema is mutated in place.
- *
- * @param {OpenAPI3} schema The OpenAPI v3 schema to hoist the shared enums of.
- * @return {string[]} The names of the hoisted definitions, in the order they were created.
- */
-function hoistSharedEnums(schema) {
-    const definitions = schema.components?.schemas;
-    if (!definitions) {
-        return [];
-    }
-    // Enums declared by identical schema content, keyed by that content
-    const groups = new Map();
-    for (const [key, definition] of Object.entries(definitions)) {
-        if (definition && typeof definition === 'object') {
-            const owner = definition['title'];
-            collectEnums(definition, typeof owner === 'string' ? owner : key, '', groups);
-        }
-    }
-    const takenNames = new Set(Object.keys(definitions));
-    for (const definition of Object.values(definitions)) {
-        const title = definition?.['title'];
-        if (typeof title === 'string') {
-            takenNames.add(title);
-        }
-    }
-    const hoistedNames = [];
-    for (const [content, occurrences] of groups) {
-        if (occurrences.length < 2) {
-            continue;
-        }
-        const name = resolveEnumName(JSON.parse(content), occurrences);
-        if (!name || takenNames.has(name)) {
-            continue;
-        }
-        takenNames.add(name);
-        hoistedNames.push(name);
-        definitions[name] = { title: name, ...JSON.parse(content) };
-        for (const { container, key } of occurrences) {
-            container[key] = {
-                $ref: `#/components/schemas/${name}`
-            };
-        }
-    }
-    return hoistedNames;
-}
-/**
- * Collects every inline enum declared below the given schema node into the groups map,
- * keyed by the stable serialization of the enum schema, so identical enums group together.
- *
- * @param {SchemaContainer} container The schema node to collect the enums of.
- * @param {string} owner The name of the definition the node belongs to.
- * @param {string} property The name of the property the node is declared under, if any.
- * @param {Map<string, EnumOccurrence[]>} groups The collected occurrences, grouped by content.
- */
-function collectEnums(container, owner, property, groups) {
-    const entries = Array.isArray(container)
-        ? container.map((value, index) => [index, value])
-        : Object.entries(container);
-    for (const [key, value] of entries) {
-        if (!value || typeof value !== 'object') {
-            continue;
-        }
-        // The keys of a `properties` object name the schemas below them, everything
-        // else keeps the property name of the node it was reached through
-        if (key === 'properties' && !Array.isArray(value)) {
-            const properties = value;
-            for (const name of Object.keys(properties)) {
-                visitSchema(properties, name, owner, name, groups);
-            }
-            continue;
-        }
-        visitSchema(container, key, owner, property, groups);
-    }
-}
-/**
- * Records the schema held by the container under the given key as an enum occurrence, or
- * descends into it when it declares no enum of its own.
- *
- * @param {SchemaContainer} container The container holding the schema node.
- * @param {string | number} key The key the schema node is held under.
- * @param {string} owner The name of the definition the node belongs to.
- * @param {string} property The name of the property the node is declared under, if any.
- * @param {Map<string, EnumOccurrence[]>} groups The collected occurrences, grouped by content.
- */
-function visitSchema(container, key, owner, property, groups) {
-    const node = container[key];
-    if (Array.isArray(node['enum'])) {
-        const content = stableStringify(node);
-        const occurrences = groups.get(content) ?? [];
-        occurrences.push({ container, key, owner, property });
-        groups.set(content, occurrences);
-        return;
-    }
-    collectEnums(node, owner, property, groups);
-}
-/**
- * Resolves the name of the definition an enum is hoisted into, preferring the name given to
- * its values by {@link SHARED_ENUM_NAMES} and falling back to the common part of the names of
- * the definitions declaring it, followed by the property name they all declare it under.
- *
- * @param {Record<string, unknown>} node The enum schema to resolve the name of.
- * @param {EnumOccurrence[]} occurrences The places the enum is declared in.
- * @return {string | undefined} The resolved name, or undefined when the enum has no name to
- * be hoisted under.
- */
-function resolveEnumName(node, occurrences) {
-    const values = node['enum'];
-    const knownName = constants_1.SHARED_ENUM_NAMES[values.join('|')];
-    if (knownName) {
-        return knownName;
-    }
-    const { property } = occurrences[0];
-    if (!property || occurrences.some((o) => o.property !== property)) {
-        return undefined;
-    }
-    const prefix = commonNamePrefix(occurrences.map((o) => o.owner));
-    if (!prefix) {
-        return undefined;
-    }
-    return prefix + property.charAt(0).toUpperCase() + property.slice(1);
-}
-/**
- * Resolves the longest prefix the given names share, cut at a word boundary so the result
- * stays a readable name (i.e. `HealthCheckResponse` and `HealthCheckResult` give
- * `HealthCheck` rather than `HealthCheckRes`).
- *
- * @param {string[]} names The names to find the common prefix of.
- * @return {string} The common prefix, empty when the names start with different words.
+ * Rewrites the TypeScript enums of the generated types into a constant object holding the
+ * members and a type alias of their values, so both forms are accepted wherever the enum is
+ * used (i.e. `SortDirection.asc` and the plain `'asc'` literal alike).
+ *
+ * A TypeScript `enum` declares a nominal type, which rejects the very literals it is built
+ * from, forcing users of the generated client to import the enum for a value the API
+ * documents as a string. The rewritten declaration keeps the member access working while
+ * typing the property as the union of its values:
+ *
+ * ```ts
+ * export const SortDirection = { asc: 'asc', desc: 'desc' } as const;
+ * export type SortDirection = (typeof SortDirection)[keyof typeof SortDirection];
+ * ```
+ *
+ * @param {string} content The generated TypeScript types to rewrite the enums of.
+ * @param {boolean} [declaration=false] Whether the types are emitted into a declaration
+ * (`.d.ts`) file, which holds no runtime values and so declares the constant instead of
+ * initializing it.
+ * @return {string} The types with every enum declaration rewritten.
  */
-function commonNamePrefix(names) {
-    const wordsPerName = names.map((name) => name.match(/[A-Z]+(?![a-z])|[A-Z]?[a-z0-9]+|[A-Z]/g) ?? []);
-    const words = [];
-    for (let i = 0; i < wordsPerName[0].length; i++) {
-        const word = wordsPerName[0][i];
-        if (wordsPerName.some((other) => other[i] !== word)) {
-            break;
-        }
-        words.push(word);
-    }
-    return words.join('');
+function rewriteEnumsAsObjects(content, declaration = false) {
+    return content.replace(/export enum (\w+) \{([^}]*)}/g, (match, name, body) => {
+        const members = parseEnumMembers(body);
+        if (members.length === 0) {
+            return match;
+        }
+        const values = members
+            .map(([member, value]) => declaration
+            ? `    readonly ${member}: ${value};`
+            : `    ${member}: ${value},`)
+            .join('\n');
+        const constant = declaration
+            ? `export declare const ${name}: {\n${values}\n};`
+            : `export const ${name} = {\n${values}\n} as const;`;
+        return `${constant}\nexport type ${name} = (typeof ${name})[keyof typeof ${name}];`;
+    });
 }
 /**
- * Serializes a value with its object keys sorted, so two schemas holding the same content
- * in a different key order serialize alike.
+ * Parses the members of an enum declaration body into their name and value pairs, keeping
+ * the value verbatim so a quoted member name or a numeric value survives the rewrite.
  *
- * @param {unknown} value The value to serialize.
- * @return {string} The stable JSON serialization of the value.
+ * @param {string} body The body of the enum declaration, without the enclosing braces.
+ * @return {[string, string][]} The name and value of every member, in declaration order.
  */
-function stableStringify(value) {
-    if (Array.isArray(value)) {
-        return `[${value.map(stableStringify).join(',')}]`;
-    }
-    if (value && typeof value === 'object') {
-        const entries = Object.keys(value)
-            .sort()
-            .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
-        return `{${entries.join(',')}}`;
-    }
-    return JSON.stringify(value) ?? 'null';
+function parseEnumMembers(body) {
+    const members = [];
+    // A member name, quoted or not, followed by its value, which is a quoted string
+    // (holding a comma of its own or not) or a number
+    const pattern = /("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|[\w$]+)\s*=\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|-?[\d.]+)/g;
+    let member;
+    while ((member = pattern.exec(body)) !== null) {
+        members.push([member[1], member[2]]);
+    }
+    return members;
 }

package/cjs/utils/hoist-util.d.ts

@@ -0,0 +1,29 @@
+import { OpenAPI3 } from 'openapi-typescript';
+/**
+ * Hoists the schemas an OpenAPI document repeats inline across its definitions into shared
+ * definitions of their own, replacing every occurrence with a reference to the hoisted
+ * definition.
+ *
+ * An Appweaver schema declares the same shapes over and over, once per property that accepts
+ * them, and each of them would otherwise be spelled out again in the generated types (i.e. the
+ * `asc | desc` enum of every sortable field, or the accepted value of every filterable field of
+ * every resource). Two kinds of schema are hoisted:
+ *
+ * - The well known shapes of {@link SHARED_SCHEMA_SHAPES}, matched in the order they are
+ *   declared so an outer shape is hoisted before the shapes nested inside it.
+ * - The enums the definitions repeat, named after {@link SHARED_ENUM_NAMES} when their values
+ *   are well known, and otherwise after the part the declaring definitions have in common
+ *   followed by the property name (i.e. `PostCreate` and `PostSingle` declaring `status` give
+ *   `PostStatus`). Enums whose name cannot be resolved are left inline.
+ *
+ * Only the structure of a schema decides whether it is hoisted, and every occurrence keeps the
+ * documentation it carries, so no property loses its description or example along the way.
+ *
+ * A schema declared only once, or whose name is already taken, is left inline as well.
+ *
+ * The given schema is mutated in place.
+ *
+ * @param {OpenAPI3} schema The OpenAPI v3 schema to hoist the shared definitions of.
+ * @return {string[]} The names of the hoisted definitions, in the order they were created.
+ */
+export declare function hoistSharedTypes(schema: OpenAPI3): string[];

package/cjs/utils/hoist-util.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hoistSharedTypes = hoistSharedTypes;
+const constants_1 = require("../constants");
+/** Keys documenting a schema node rather than describing its structure. They are kept on the
+ * property the node is hoisted out of, so no property loses its description along the way. */
+const ANNOTATION_KEYS = ['description', 'example', 'examples', 'deprecated'];
+/**
+ * Hoists the schemas an OpenAPI document repeats inline across its definitions into shared
+ * definitions of their own, replacing every occurrence with a reference to the hoisted
+ * definition.
+ *
+ * An Appweaver schema declares the same shapes over and over, once per property that accepts
+ * them, and each of them would otherwise be spelled out again in the generated types (i.e. the
+ * `asc | desc` enum of every sortable field, or the accepted value of every filterable field of
+ * every resource). Two kinds of schema are hoisted:
+ *
+ * - The well known shapes of {@link SHARED_SCHEMA_SHAPES}, matched in the order they are
+ *   declared so an outer shape is hoisted before the shapes nested inside it.
+ * - The enums the definitions repeat, named after {@link SHARED_ENUM_NAMES} when their values
+ *   are well known, and otherwise after the part the declaring definitions have in common
+ *   followed by the property name (i.e. `PostCreate` and `PostSingle` declaring `status` give
+ *   `PostStatus`). Enums whose name cannot be resolved are left inline.
+ *
+ * Only the structure of a schema decides whether it is hoisted, and every occurrence keeps the
+ * documentation it carries, so no property loses its description or example along the way.
+ *
+ * A schema declared only once, or whose name is already taken, is left inline as well.
+ *
+ * The given schema is mutated in place.
+ *
+ * @param {OpenAPI3} schema The OpenAPI v3 schema to hoist the shared definitions of.
+ * @return {string[]} The names of the hoisted definitions, in the order they were created.
+ */
+function hoistSharedTypes(schema) {
+    const definitions = schema.components?.schemas;
+    if (!definitions) {
+        return [];
+    }
+    const takenNames = new Set(Object.keys(definitions));
+    for (const definition of Object.values(definitions)) {
+        const title = definition?.['title'];
+        if (typeof title === 'string') {
+            takenNames.add(title);
+        }
+    }
+    const hoistedNames = [];
+    for (const { name, schema: shape } of constants_1.SHARED_SCHEMA_SHAPES) {
+        if (hoistShape(definitions, name, shape, takenNames)) {
+            hoistedNames.push(name);
+        }
+    }
+    hoistedNames.push(...hoistEnums(definitions, takenNames));
+    return hoistedNames;
+}
+/**
+ * Hoists every occurrence of a well known shape into a definition of the given name. The
+ * definition is built from the first occurrence, so it holds the references the shape declares
+ * by title as the references of the document.
+ *
+ * @param {Record<string, unknown>} definitions The definitions of the schema.
+ * @param {string} name The name of the definition the shape is hoisted into.
+ * @param {unknown} shape The shape to hoist, holding its references as definition titles.
+ * @param {Set<string>} takenNames The definition names already in use.
+ * @return {boolean} Whether the shape was hoisted.
+ */
+function hoistShape(definitions, name, shape, takenNames) {
+    const titles = definitionTitles(definitions);
+    const signature = schemaSignature(shape, titles);
+    const groups = collectOccurrences(definitions, (node) => schemaSignature(structure(node), titles) === signature ? name : undefined);
+    const occurrences = groups.get(name);
+    if (!occurrences || occurrences.length < 2 || takenNames.has(name)) {
+        return false;
+    }
+    takenNames.add(name);
+    const { container, key } = occurrences[0];
+    definitions[name] = {
+        title: name,
+        ...structure(container[key])
+    };
+    for (const occurrence of occurrences) {
+        replaceWithReference(occurrence, name);
+    }
+    return true;
+}
+/**
+ * Hoists the enums the definitions repeat into shared definitions named after their values.
+ *
+ * @param {Record<string, unknown>} definitions The definitions of the schema.
+ * @param {Set<string>} takenNames The definition names already in use.
+ * @return {string[]} The names of the hoisted definitions, in the order they were created.
+ */
+function hoistEnums(definitions, takenNames) {
+    // Enums declared by identical schema content, keyed by that content. The
+    // documentation of a node is left out of the key, since every occurrence keeps
+    // the documentation of its own when it is replaced by a reference
+    const groups = collectOccurrences(definitions, (node) => Array.isArray(node['enum']) ? stableStringify(structure(node)) : undefined);
+    const hoistedNames = [];
+    for (const [content, occurrences] of groups) {
+        if (occurrences.length < 2) {
+            continue;
+        }
+        const name = resolveEnumName(JSON.parse(content), occurrences);
+        if (!name || takenNames.has(name)) {
+            continue;
+        }
+        takenNames.add(name);
+        hoistedNames.push(name);
+        definitions[name] = { title: name, ...JSON.parse(content) };
+        for (const occurrence of occurrences) {
+            replaceWithReference(occurrence, name);
+        }
+    }
+    return hoistedNames;
+}
+/**
+ * Replaces the schema node of an occurrence with a reference to the given definition, keeping
+ * the documentation the node carries.
+ *
+ * @param {Occurrence} occurrence The occurrence to replace.
+ * @param {string} name The name of the definition to reference.
+ */
+function replaceWithReference({ container, key }, name) {
+    const node = container[key];
+    container[key] = {
+        ...annotations(node),
+        $ref: `#/components/schemas/${name}`
+    };
+}
+/**
+ * Collects every inline schema the matcher accepts into a map of occurrences, grouped by the
+ * key the matcher returns for them. A node the matcher accepts is not descended into, so an
+ * outer match wins over the nodes nested inside it.
+ *
+ * @param {Record<string, unknown>} definitions The definitions of the schema.
+ * @param {Matcher} match The matcher deciding which nodes are collected.
+ * @return {Map<string, Occurrence[]>} The collected occurrences, grouped by matcher key.
+ */
+function collectOccurrences(definitions, match) {
+    const groups = new Map();
+    for (const [key, definition] of Object.entries(definitions)) {
+        if (definition && typeof definition === 'object') {
+            const owner = definition['title'];
+            collect(definition, typeof owner === 'string' ? owner : key, '', match, groups);
+        }
+    }
+    return groups;
+}
+/**
+ * Collects every inline schema declared below the given schema node into the groups map.
+ *
+ * @param {SchemaContainer} container The schema node to collect the schemas of.
+ * @param {string} owner The name of the definition the node belongs to.
+ * @param {string} property The name of the property the node is declared under, if any.
+ * @param {Matcher} match The matcher deciding which nodes are collected.
+ * @param {Map<string, Occurrence[]>} groups The collected occurrences, grouped by matcher key.
+ */
+function collect(container, owner, property, match, groups) {
+    const entries = Array.isArray(container)
+        ? container.map((value, index) => [index, value])
+        : Object.entries(container);
+    for (const [key, value] of entries) {
+        if (!value || typeof value !== 'object') {
+            continue;
+        }
+        // The keys of a `properties` object name the schemas below them, everything
+        // else keeps the property name of the node it was reached through
+        if (key === 'properties' && !Array.isArray(value)) {
+            const properties = value;
+            for (const name of Object.keys(properties)) {
+                visit(properties, name, owner, name, match, groups);
+            }
+            continue;
+        }
+        visit(container, key, owner, property, match, groups);
+    }
+}
+/**
+ * Records the schema held by the container under the given key as an occurrence, or descends
+ * into it when the matcher does not accept it.
+ *
+ * @param {SchemaContainer} container The container holding the schema node.
+ * @param {string | number} key The key the schema node is held under.
+ * @param {string} owner The name of the definition the node belongs to.
+ * @param {string} property The name of the property the node is declared under, if any.
+ * @param {Matcher} match The matcher deciding which nodes are collected.
+ * @param {Map<string, Occurrence[]>} groups The collected occurrences, grouped by matcher key.
+ */
+function visit(container, key, owner, property, match, groups) {
+    const node = container[key];
+    const group = match(node);
+    if (group !== undefined) {
+        const occurrences = groups.get(group) ?? [];
+        occurrences.push({ container, key, owner, property });
+        groups.set(group, occurrences);
+        return;
+    }
+    collect(node, owner, property, match, groups);
+}
+/**
+ * Resolves the name of the definition an enum is hoisted into, preferring the name given to
+ * its values by {@link SHARED_ENUM_NAMES} and falling back to the common part of the names of
+ * the definitions declaring it, followed by the property name they all declare it under.
+ *
+ * @param {SchemaNode} node The enum schema to resolve the name of.
+ * @param {Occurrence[]} occurrences The places the enum is declared in.
+ * @return {string | undefined} The resolved name, or undefined when the enum has no name to
+ * be hoisted under.
+ */
+function resolveEnumName(node, occurrences) {
+    const values = node['enum'];
+    const knownName = constants_1.SHARED_ENUM_NAMES[values.join('|')];
+    if (knownName) {
+        return knownName;
+    }
+    const { property } = occurrences[0];
+    if (!property || occurrences.some((o) => o.property !== property)) {
+        return undefined;
+    }
+    const prefix = commonNamePrefix(occurrences.map((o) => o.owner));
+    if (!prefix) {
+        return undefined;
+    }
+    return prefix + property.charAt(0).toUpperCase() + property.slice(1);
+}
+/**
+ * Resolves the longest prefix the given names share, cut at a word boundary so the result
+ * stays a readable name (i.e. `HealthCheckResponse` and `HealthCheckResult` give
+ * `HealthCheck` rather than `HealthCheckRes`).
+ *
+ * @param {string[]} names The names to find the common prefix of.
+ * @return {string} The common prefix, empty when the names start with different words.
+ */
+function commonNamePrefix(names) {
+    const wordsPerName = names.map((name) => name.match(/[A-Z]+(?![a-z])|[A-Z]?[a-z0-9]+|[A-Z]/g) ?? []);
+    const words = [];
+    for (let i = 0; i < wordsPerName[0].length; i++) {
+        const word = wordsPerName[0][i];
+        if (wordsPerName.some((other) => other[i] !== word)) {
+            break;
+        }
+        words.push(word);
+    }
+    return words.join('');
+}
+/**
+ * Maps every definition key to the title it is generated under, so a reference can be compared
+ * by the name it resolves to rather than by the generated key holding it.
+ *
+ * @param {Record<string, unknown>} definitions The definitions of the schema.
+ * @return {Map<string, string>} The title of every definition, keyed by its definition key.
+ */
+function definitionTitles(definitions) {
+    const titles = new Map();
+    for (const [key, definition] of Object.entries(definitions)) {
+        const title = definition?.['title'];
+        titles.set(key, typeof title === 'string' ? title : key);
+    }
+    return titles;
+}
+/**
+ * Returns the documentation keys of a schema node, which the node keeps when it is replaced by
+ * a reference to a hoisted definition.
+ *
+ * @param {SchemaNode} node The schema node to take the documentation of.
+ * @return {SchemaNode} The documentation keys of the node.
+ */
+function annotations(node) {
+    return Object.fromEntries(Object.entries(node).filter(([key]) => ANNOTATION_KEYS.includes(key)));
+}
+/**
+ * Returns the structural keys of a schema node, so two nodes describing the same shape under a
+ * different description compare alike.
+ *
+ * @param {SchemaNode} node The schema node to take the structure of.
+ * @return {SchemaNode} The structural keys of the node.
+ */
+function structure(node) {
+    return Object.fromEntries(Object.entries(node).filter(([key]) => !ANNOTATION_KEYS.includes(key)));
+}
+/**
+ * Serializes a schema with its references resolved to the title of the definition they point
+ * to, so a shape declared by {@link SHARED_SCHEMA_SHAPES} compares equal to the same shape of a
+ * document, whose references name the generated definition keys instead.
+ *
+ * @param {unknown} value The schema to serialize.
+ * @param {Map<string, string>} titles The title of every definition, keyed by definition key.
+ * @return {string} The stable serialization of the schema.
+ */
+function schemaSignature(value, titles) {
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => schemaSignature(item, titles)).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.keys(value)
+            .sort()
+            .map((key) => {
+            const nested = value[key];
+            const resolved = key === '$ref' && typeof nested === 'string'
+                ? JSON.stringify(referenceTitle(nested, titles))
+                : schemaSignature(nested, titles);
+            return `${JSON.stringify(key)}:${resolved}`;
+        });
+        return `{${entries.join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'null';
+}
+/**
+ * Resolves a reference to the title of the definition it points to.
+ *
+ * @param {string} reference The reference to resolve (i.e. `#/components/schemas/def-1`).
+ * @param {Map<string, string>} titles The title of every definition, keyed by definition key.
+ * @return {string} The title of the referenced definition, or the reference when it points
+ * outside of the definitions of the document.
+ */
+function referenceTitle(reference, titles) {
+    const key = reference.replace('#/components/schemas/', '');
+    return titles.get(key) ?? reference;
+}
+/**
+ * Serializes a value with its object keys sorted, so two schemas holding the same content
+ * in a different key order serialize alike.
+ *
+ * @param {unknown} value The value to serialize.
+ * @return {string} The stable JSON serialization of the value.
+ */
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.keys(value)
+            .sort()
+            .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
+        return `{${entries.join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'null';
+}

package/cjs/utils/index.d.ts

@@ -1,2 +1,3 @@
 export * from './enum-util';
+export * from './hoist-util';
 export * from './schema-util';

package/cjs/utils/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./enum-util"), exports);
+__exportStar(require("./hoist-util"), exports);
 __exportStar(require("./schema-util"), exports);