quicktype-core 23.0.158 → 23.0.160

package/dist/Annotation.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nullTypeIssueAnnotation = exports.anyTypeIssueAnnotation = exports.IssueAnnotationData = exports.AnnotationData = void 0;
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 class AnnotationData {
 }
 exports.AnnotationData = AnnotationData;

package/dist/ConvenienceRenderer.d.ts

@@ -1,17 +1,17 @@
-import { Type, ClassType, EnumType, UnionType, TypeKind, ClassProperty, ObjectType } from "./Type";
-import { Namespace, Name, Namer, DependencyName } from "./Naming";
-import { Renderer, BlankLineConfig, RenderContext, ForEachPosition } from "./Renderer";
-import { Sourcelike } from "./Source";
-import { Declaration } from "./DeclarationIR";
-import { Transformation } from "./Transformers";
-import { TargetLanguage } from "./TargetLanguage";
+import { type Declaration } from "./DeclarationIR";
+import { DependencyName, type Name, type Namer, Namespace } from "./Naming";
+import { type BlankLineConfig, type ForEachPosition, type RenderContext, Renderer } from "./Renderer";
+import { type Sourcelike } from "./Source";
 import { type Comment, type CommentOptions } from "./support/Comments";
+import { type TargetLanguage } from "./TargetLanguage";
+import { type Transformation } from "./Transformers";
+import { type ClassProperty, ClassType, EnumType, ObjectType, type Type, type TypeKind, UnionType } from "./Type";
 export declare const topLevelNameOrder = 1;
 export declare const inferredNameOrder = 30;
-export type ForbiddenWordsInfo = {
-    names: (Name | string)[];
+export interface ForbiddenWordsInfo {
     includeGlobalForbidden: boolean;
-};
+    names: Array<Name | string>;
+}
 export declare abstract class ConvenienceRenderer extends Renderer {
     private _globalForbiddenNamespace;
     private _otherForbiddenNamespaces;
@@ -121,7 +121,7 @@ export declare abstract class ConvenienceRenderer extends Renderer {
     protected forEachUnionMember(u: UnionType, members: ReadonlySet<Type> | null, blankLocations: BlankLineConfig, sortOrder: ((n: Name, t: Type) => string) | null, f: (name: Name, t: Type, position: ForEachPosition) => void): void;
     protected forEachEnumCase(e: EnumType, blankLocations: BlankLineConfig, f: (name: Name, jsonName: string, position: ForEachPosition) => void): void;
     protected forEachTransformation(blankLocations: BlankLineConfig, f: (n: Name, t: Type, position: ForEachPosition) => void): void;
-    protected forEachSpecificNamedType<T extends Type>(blankLocations: BlankLineConfig, types: Iterable<[any, T]>, f: (t: T, name: Name, position: ForEachPosition) => void): void;
+    protected forEachSpecificNamedType<T extends Type>(blankLocations: BlankLineConfig, types: Iterable<[T, T]>, f: (t: T, name: Name, position: ForEachPosition) => void): void;
     protected forEachObject(blankLocations: BlankLineConfig, f: ((c: ClassType, className: Name, position: ForEachPosition) => void) | ((o: ObjectType, objectName: Name, position: ForEachPosition) => void)): void;
     protected forEachEnum(blankLocations: BlankLineConfig, f: (u: EnumType, enumName: Name, position: ForEachPosition) => void): void;
     protected forEachUnion(blankLocations: BlankLineConfig, f: (u: UnionType, unionName: Name, position: ForEachPosition) => void): void;

package/dist/ConvenienceRenderer.js

@@ -1,22 +1,26 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConvenienceRenderer = exports.inferredNameOrder = exports.topLevelNameOrder = void 0;
 const collection_utils_1 = require("collection-utils");
-const Type_1 = require("./Type");
-const TypeUtils_1 = require("./TypeUtils");
+const wordwrap_1 = __importDefault(require("wordwrap"));
+const AccessorNames_1 = require("./attributes/AccessorNames");
+const Description_1 = require("./attributes/Description");
+const TypeAttributes_1 = require("./attributes/TypeAttributes");
+const DeclarationIR_1 = require("./DeclarationIR");
 const Naming_1 = require("./Naming");
 const Renderer_1 = require("./Renderer");
-const Support_1 = require("./support/Support");
-const Strings_1 = require("./support/Strings");
 const Source_1 = require("./Source");
-const DeclarationIR_1 = require("./DeclarationIR");
-const TypeGraph_1 = require("./TypeGraph");
-const TypeAttributes_1 = require("./attributes/TypeAttributes");
-const Description_1 = require("./attributes/Description");
-const AccessorNames_1 = require("./attributes/AccessorNames");
-const Transformers_1 = require("./Transformers");
 const Comments_1 = require("./support/Comments");
-const wordWrap = require("wordwrap")(90);
+const Strings_1 = require("./support/Strings");
+const Support_1 = require("./support/Support");
+const Transformers_1 = require("./Transformers");
+const Type_1 = require("./Type");
+const TypeGraph_1 = require("./TypeGraph");
+const TypeUtils_1 = require("./TypeUtils");
+const wordWrap = (0, wordwrap_1.default)(90);
 exports.topLevelNameOrder = 1;
 const givenNameOrder = 10;
 exports.inferredNameOrder = 30;
@@ -482,9 +486,9 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         return (0, Support_1.defined)(caseNames.get(caseName));
     }
     forEachUnionMember(u, members, blankLocations, sortOrder, f) {
-        const iterateMembers = members === null ? u.members : members;
+        const iterateMembers = members !== null && members !== void 0 ? members : u.members;
         if (sortOrder === null) {
-            sortOrder = n => (0, Support_1.defined)(this.names.get(n));
+            sortOrder = (n) => (0, Support_1.defined)(this.names.get(n));
         }
         const memberNames = (0, collection_utils_1.mapFilter)((0, Support_1.defined)(this._memberNamesStoreView).get(u), (_, t) => iterateMembers.has(t));
         const sortedMemberNames = (0, collection_utils_1.mapSortBy)(memberNames, sortOrder);
@@ -616,7 +620,7 @@ class ConvenienceRenderer extends Renderer_1.Renderer {
         emitTable();
     }
     processGraph() {
-        this._declarationIR = (0, DeclarationIR_1.declarationsForGraph)(this.typeGraph, this.needsTypeDeclarationBeforeUse ? t => this.canBeForwardDeclared(t) : undefined, t => this.childrenOfType(t), t => {
+        this._declarationIR = (0, DeclarationIR_1.declarationsForGraph)(this.typeGraph, this.needsTypeDeclarationBeforeUse ? (t) => this.canBeForwardDeclared(t) : undefined, t => this.childrenOfType(t), t => {
             if (t instanceof Type_1.UnionType) {
                 return this.unionNeedsName(t);
             }

package/dist/CycleBreaker.d.ts

@@ -1 +1 @@
-export declare function breakCycles<T>(outEdges: number[][], chooseBreaker: (cycle: number[]) => [number, T]): [number, T][];
+export declare function breakCycles<T>(outEdges: number[][], chooseBreaker: (cycle: number[]) => [number, T]): Array<[number, T]>;

package/dist/CycleBreaker.js

@@ -86,7 +86,7 @@ function breakCycles(outEdges, chooseBreaker) {
             // We found a cycle - break it
             const cycle = path.slice(maybeFirst);
             const [breakNode, info] = chooseBreaker(cycle);
-            (0, Support_1.assert)(cycle.indexOf(breakNode) >= 0, "Breaker chose an invalid node");
+            (0, Support_1.assert)(cycle.includes(breakNode), "Breaker chose an invalid node");
             removeNode(breakNode);
             results.push([breakNode, info]);
             break;

package/dist/DateTime.d.ts

@@ -1,7 +1,7 @@
 export interface DateTimeRecognizer {
-    isDate(s: string): boolean;
-    isTime(s: string): boolean;
-    isDateTime(s: string): boolean;
+    isDate: (s: string) => boolean;
+    isDateTime: (s: string) => boolean;
+    isTime: (s: string) => boolean;
 }
 export declare class DefaultDateTimeRecognizer implements DateTimeRecognizer {
     isDate(str: string): boolean;

package/dist/DateTime.js

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable */
 // https://github.com/epoberezkin/ajv/blob/4d76c6fb813b136b6ec4fe74990bc97233d75dea/lib/compile/formats.js
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultDateTimeRecognizer = void 0;
@@ -32,7 +33,7 @@ const DATE_TIME_SEPARATOR = /t|\s/i;
 class DefaultDateTimeRecognizer {
     isDate(str) {
         // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
-        const matches = str.match(DATE);
+        const matches = DATE.exec(str);
         if (matches === null)
             return false;
         const month = +matches[2];
@@ -40,7 +41,7 @@ class DefaultDateTimeRecognizer {
         return month >= 1 && month <= 12 && day >= 1 && day <= DAYS[month];
     }
     isTime(str) {
-        const matches = str.match(TIME);
+        const matches = TIME.exec(str);
         if (matches === null)
             return false;
         const hour = +matches[1];

package/dist/DeclarationIR.d.ts

@@ -1,5 +1,5 @@
-import { TypeGraph } from "./TypeGraph";
-import { Type } from "./Type";
+import { type Type } from "./Type";
+import { type TypeGraph } from "./TypeGraph";
 export type DeclarationKind = "forward" | "define";
 export interface Declaration {
     readonly kind: DeclarationKind;
@@ -7,7 +7,7 @@ export interface Declaration {
 }
 export declare class DeclarationIR {
     readonly forwardedTypes: Set<Type>;
-    readonly declarations: ReadonlyArray<Declaration>;
+    readonly declarations: readonly Declaration[];
     constructor(declarations: Iterable<Declaration>, forwardedTypes: Set<Type>);
 }
 export declare function cycleBreakerTypesForGraph(graph: TypeGraph, isImplicitCycleBreaker: (t: Type) => boolean, canBreakCycles: (t: Type) => boolean): Set<Type>;

package/dist/DeclarationIR.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.declarationsForGraph = exports.cycleBreakerTypesForGraph = exports.DeclarationIR = void 0;
 const collection_utils_1 = require("collection-utils");
-const Support_1 = require("./support/Support");
 const Graph_1 = require("./Graph");
 const Messages_1 = require("./Messages");
+const Support_1 = require("./support/Support");
 class DeclarationIR {
     constructor(declarations, forwardedTypes) {
         this.forwardedTypes = forwardedTypes;

package/dist/GatherNames.d.ts

@@ -1,2 +1,2 @@
-import { TypeGraph } from "./TypeGraph";
+import { type TypeGraph } from "./TypeGraph";
 export declare function gatherNames(graph: TypeGraph, destructive: boolean, debugPrint: boolean): void;

package/dist/GatherNames.js

@@ -24,13 +24,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gatherNames = void 0;
-const pluralize = __importStar(require("pluralize"));
 const collection_utils_1 = require("collection-utils");
-const Type_1 = require("./Type");
-const TypeUtils_1 = require("./TypeUtils");
+const pluralize = __importStar(require("pluralize"));
 const TypeNames_1 = require("./attributes/TypeNames");
 const Support_1 = require("./support/Support");
 const Transformers_1 = require("./Transformers");
+const Type_1 = require("./Type");
+const TypeUtils_1 = require("./TypeUtils");
 class UniqueQueue {
     constructor() {
         this._present = new Set();

package/dist/Graph.d.ts

@@ -4,7 +4,7 @@ export declare class Graph<T> {
     private readonly _successors;
     constructor(nodes: Iterable<T>, invertDirection: boolean, edges: number[][] | ((node: T) => ReadonlySet<T>));
     get size(): number;
-    get nodes(): ReadonlyArray<T>;
+    get nodes(): readonly T[];
     findRoots(): ReadonlySet<T>;
     dfsTraversal(root: T, preOrder: boolean, process: (node: T) => void): void;
     stronglyConnectedComponents(): Graph<ReadonlySet<T>>;

package/dist/GraphRewriting.d.ts

@@ -1,10 +1,10 @@
-import { PrimitiveTypeKind, Type, ClassProperty, MaybeTypeIdentity } from "./Type";
-import { TypeGraph, TypeRef } from "./TypeGraph";
-import { TypeAttributes } from "./attributes/TypeAttributes";
-import { TypeBuilder, StringTypeMapping } from "./TypeBuilder";
+import { type TypeAttributes } from "./attributes/TypeAttributes";
+import { type ClassProperty, type MaybeTypeIdentity, type PrimitiveTypeKind, type Type } from "./Type";
+import { type StringTypeMapping, TypeBuilder } from "./TypeBuilder";
+import { type TypeGraph, type TypeRef } from "./TypeGraph";
 export interface TypeLookerUp {
-    lookupTypeRefs(typeRefs: TypeRef[], forwardingRef?: TypeRef): TypeRef | undefined;
-    reconstituteTypeRef(typeRef: TypeRef, attributes?: TypeAttributes, forwardingRef?: TypeRef): TypeRef;
+    lookupTypeRefs: (typeRefs: TypeRef[], forwardingRef?: TypeRef) => TypeRef | undefined;
+    reconstituteTypeRef: (typeRef: TypeRef, attributes?: TypeAttributes, forwardingRef?: TypeRef) => TypeRef;
 }
 export declare class TypeReconstituter<TBuilder extends BaseGraphRewriteBuilder> {
     private readonly _typeBuilder;
@@ -21,10 +21,10 @@ export declare class TypeReconstituter<TBuilder extends BaseGraphRewriteBuilder>
     private register;
     private registerAndAddAttributes;
     lookup(tref: TypeRef): TypeRef | undefined;
-    lookup(trefs: Iterable<TypeRef>): ReadonlyArray<TypeRef> | undefined;
+    lookup(trefs: Iterable<TypeRef>): readonly TypeRef[] | undefined;
     lookupMap<K>(trefs: ReadonlyMap<K, TypeRef>): ReadonlyMap<K, TypeRef> | undefined;
     reconstitute(tref: TypeRef): TypeRef;
-    reconstitute(trefs: Iterable<TypeRef>): ReadonlyArray<TypeRef>;
+    reconstitute(trefs: Iterable<TypeRef>): readonly TypeRef[];
     reconstituteMap<K>(trefs: ReadonlyMap<K, TypeRef>): ReadonlyMap<K, TypeRef>;
     getPrimitiveType(kind: PrimitiveTypeKind): void;
     getEnumType(cases: ReadonlySet<string>): void;

package/dist/GraphRewriting.js

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphRewriteBuilder = exports.GraphRemapBuilder = exports.BaseGraphRewriteBuilder = exports.TypeReconstituter = void 0;
 const collection_utils_1 = require("collection-utils");
-const TypeUtils_1 = require("./TypeUtils");
-const TypeGraph_1 = require("./TypeGraph");
 const TypeAttributes_1 = require("./attributes/TypeAttributes");
 const Support_1 = require("./support/Support");
+// eslint-disable-next-line import/no-cycle
 const TypeBuilder_1 = require("./TypeBuilder");
+const TypeGraph_1 = require("./TypeGraph");
+const TypeUtils_1 = require("./TypeUtils");
 class TypeReconstituter {
     constructor(_typeBuilder, _makeClassUnique, _typeAttributes, _forwardingRef, _register) {
         this._typeBuilder = _typeBuilder;
@@ -356,7 +357,7 @@ class GraphRewriteBuilder extends BaseGraphRewriteBuilder {
         return reconstituter.getResult();
     }
     /*
-    reconstituteTypeUnmodified(originalType: Type): TypeRef {
+     public reconstituteTypeUnmodified(originalType: Type): TypeRef {
         const reconstituter = new TypeReconstituter(
             this,
             this.alphabetizeProperties,

package/dist/MakeTransformations.d.ts

@@ -1,4 +1,4 @@
-import { TypeGraph } from "./TypeGraph";
-import { TargetLanguage } from "./TargetLanguage";
-import { RunContext } from "./Run";
+import { type RunContext } from "./Run";
+import { type TargetLanguage } from "./TargetLanguage";
+import { type TypeGraph } from "./TypeGraph";
 export declare function makeTransformations(ctx: RunContext, graph: TypeGraph, targetLanguage: TargetLanguage): TypeGraph;

package/dist/MakeTransformations.js

@@ -2,19 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeTransformations = void 0;
 const collection_utils_1 = require("collection-utils");
-const TypeGraph_1 = require("./TypeGraph");
-const Type_1 = require("./Type");
+const Constraints_1 = require("./attributes/Constraints");
+const StringTypes_1 = require("./attributes/StringTypes");
+const TypeAttributes_1 = require("./attributes/TypeAttributes");
 const Support_1 = require("./support/Support");
 const Transformers_1 = require("./Transformers");
-const TypeAttributes_1 = require("./attributes/TypeAttributes");
-const StringTypes_1 = require("./attributes/StringTypes");
-const Constraints_1 = require("./attributes/Constraints");
+const Type_1 = require("./Type");
+const TypeGraph_1 = require("./TypeGraph");
 function transformationAttributes(graph, reconstitutedTargetType, transformer, debugPrintTransformations) {
     const transformation = new Transformers_1.Transformation(graph, reconstitutedTargetType, transformer);
     if (debugPrintTransformations) {
         console.log(`transformation for ${(0, TypeGraph_1.typeRefIndex)(reconstitutedTargetType)}:`);
         transformation.debugPrint();
-        console.log(`reverse:`);
+        console.log("reverse:");
         transformation.reverse.debugPrint();
     }
     return Transformers_1.transformationTypeAttributeKind.makeAttributes(transformation);
@@ -109,7 +109,7 @@ function replaceUnion(union, builder, forwardingRef, transformedTypes, debugPrin
     const transformerForClass = transformerForKind("class");
     const transformerForMap = transformerForKind("map");
     (0, Support_1.assert)(transformerForClass === undefined || transformerForMap === undefined, "Can't have both class and map in a transformed union");
-    const transformerForObject = transformerForClass !== undefined ? transformerForClass : transformerForMap;
+    const transformerForObject = transformerForClass !== null && transformerForClass !== void 0 ? transformerForClass : transformerForMap;
     const transformer = new Transformers_1.DecodingChoiceTransformer(graph, builder.getPrimitiveType("any"), transformerForKind("null"), transformerForKind("integer"), transformerForKind("double"), transformerForKind("bool"), transformerForString, transformerForKind("array"), transformerForObject);
     const attributes = transformationAttributes(graph, reconstitutedTargetType, transformer, debugPrintTransformations);
     return builder.getPrimitiveType("any", (0, TypeAttributes_1.combineTypeAttributes)("union", attributes, additionalAttributes), forwardingRef);

package/dist/MarkovChain.d.ts

@@ -1,12 +1,12 @@
 export type SubTrie = number | null | Trie;
-export type Trie = {
-    count: number;
+export interface Trie {
     arr: SubTrie[];
-};
-export type MarkovChain = {
-    trie: Trie;
+    count: number;
+}
+export interface MarkovChain {
     depth: number;
-};
+    trie: Trie;
+}
 export declare function train(lines: string[], depth: number): MarkovChain;
 export declare function load(): MarkovChain;
 export declare function evaluateFull(mc: MarkovChain, word: string): [number, number[]];

package/dist/MarkovChain.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.test = exports.generate = exports.evaluate = exports.evaluateFull = exports.load = exports.train = void 0;
-const Support_1 = require("./support/Support");
 const EncodedMarkovChain_1 = require("./EncodedMarkovChain");
+const Support_1 = require("./support/Support");
 function makeTrie() {
     const arr = [];
     for (let i = 0; i < 128; i++) {
@@ -56,7 +56,7 @@ function increment(t, seq, i) {
     if (typeof st !== "object") {
         return (0, Support_1.panic)("Malformed trie");
     }
-    return increment(st, seq, i + 1);
+    increment(st, seq, i + 1);
 }
 function train(lines, depth) {
     const trie = makeTrie();

package/dist/Messages.d.ts

@@ -1,5 +1,5 @@
-import { StringMap } from "./support/Support";
-import { Ref } from "./input/JSONSchemaInput";
+import { type Ref } from "./input/JSONSchemaInput";
+import { type StringMap } from "./support/Support";
 export type ErrorProperties = {
     kind: "InternalError";
     properties: {
@@ -8,8 +8,8 @@ export type ErrorProperties = {
 } | {
     kind: "MiscJSONParseError";
     properties: {
-        description: string;
         address: string;
+        description: string;
         message: string;
     };
 } | {
@@ -24,8 +24,8 @@ export type ErrorProperties = {
 } | {
     kind: "MiscInvalidMinMaxConstraint";
     properties: {
-        min: number;
         max: number;
+        min: number;
     };
 } | {
     kind: "InferenceJSONReferenceNotRooted";
@@ -76,8 +76,8 @@ export type ErrorProperties = {
 } | {
     kind: "SchemaInvalidType";
     properties: {
-        type: string;
         ref: Ref;
+        type: string;
     };
 } | {
     kind: "SchemaFalseNotSupported";
@@ -87,8 +87,8 @@ export type ErrorProperties = {
 } | {
     kind: "SchemaInvalidJSONSchemaType";
     properties: {
-        type: string;
         ref: Ref;
+        type: string;
     };
 } | {
     kind: "SchemaRequiredMustBeStringOrStringArray";
@@ -134,8 +134,8 @@ export type ErrorProperties = {
 } | {
     kind: "SchemaSetOperationCasesIsNotArray";
     properties: {
-        operation: string;
         cases: any;
+        operation: string;
         ref: Ref;
     };
 } | {
@@ -267,8 +267,8 @@ export type ErrorProperties = {
 } | {
     kind: "RendererUnknownOptionValue";
     properties: {
-        value: string;
         name: string;
+        value: string;
     };
 } | {
     kind: "TypeScriptCompilerError";
@@ -287,6 +287,7 @@ export type ErrorPropertiesForName<K> = Extract<ErrorProperties, {
 export declare class QuickTypeError extends Error {
     readonly errorMessage: string;
     readonly messageName: string;
+    userMessage: string;
     readonly properties: StringMap;
     constructor(errorMessage: string, messageName: string, userMessage: string, properties: StringMap);
 }

package/dist/Messages.js

@@ -70,6 +70,7 @@ class QuickTypeError extends Error {
         super(userMessage);
         this.errorMessage = errorMessage;
         this.messageName = messageName;
+        this.userMessage = userMessage;
         this.properties = properties;
     }
 }

package/dist/Naming.d.ts

@@ -14,6 +14,7 @@ export type NameStyle = (rawName: string) => string;
 export declare class Namer {
     readonly name: string;
     readonly nameStyle: NameStyle;
+    prefixes: string[];
     private readonly _prefixes;
     constructor(name: string, nameStyle: NameStyle, prefixes: string[]);
     assignNames(names: ReadonlyMap<Name, string>, forbiddenNamesIterable: Iterable<string>, namesToAssignIterable: Iterable<Name>): ReadonlyMap<Name, string>;
@@ -25,7 +26,7 @@ export declare abstract class Name {
     private readonly _associates;
     constructor(_namingFunction: Namer | undefined, order: number);
     addAssociate(associate: AssociatedName): void;
-    abstract get dependencies(): ReadonlyArray<Name>;
+    abstract get dependencies(): readonly Name[];
     isFixed(): this is FixedName;
     get namingFunction(): Namer;
     abstract proposeUnstyledNames(names: ReadonlyMap<Name, string>): ReadonlySet<string>;
@@ -35,7 +36,7 @@ export declare abstract class Name {
 export declare class FixedName extends Name {
     private readonly _fixedName;
     constructor(_fixedName: string);
-    get dependencies(): ReadonlyArray<Name>;
+    get dependencies(): readonly Name[];
     addAssociate(_: AssociatedName): never;
     get fixedName(): string;
     proposeUnstyledNames(_?: ReadonlyMap<Name, string>): ReadonlySet<string>;
@@ -43,21 +44,21 @@ export declare class FixedName extends Name {
 export declare class SimpleName extends Name {
     private readonly _unstyledNames;
     constructor(unstyledNames: Iterable<string>, namingFunction: Namer, order: number);
-    get dependencies(): ReadonlyArray<Name>;
+    get dependencies(): readonly Name[];
     proposeUnstyledNames(_?: ReadonlyMap<Name, string>): ReadonlySet<string>;
 }
 export declare class AssociatedName extends Name {
     private readonly _sponsor;
     readonly getName: (sponsorName: string) => string;
     constructor(_sponsor: Name, order: number, getName: (sponsorName: string) => string);
-    get dependencies(): ReadonlyArray<Name>;
+    get dependencies(): readonly Name[];
     proposeUnstyledNames(_?: ReadonlyMap<Name, string>): never;
 }
 export declare class DependencyName extends Name {
     private readonly _proposeUnstyledName;
     private readonly _dependencies;
     constructor(namingFunction: Namer | undefined, order: number, _proposeUnstyledName: (lookup: (n: Name) => string) => string);
-    get dependencies(): ReadonlyArray<Name>;
+    get dependencies(): readonly Name[];
     proposeUnstyledNames(names: ReadonlyMap<Name, string>): ReadonlySet<string>;
 }
 export declare function keywordNamespace(name: string, keywords: string[]): Namespace;

package/dist/Naming.js

@@ -50,6 +50,7 @@ class Namer {
     constructor(name, nameStyle, prefixes) {
         this.name = name;
         this.nameStyle = nameStyle;
+        this.prefixes = prefixes;
         this._prefixes = new Set(prefixes);
     }
     // The namesIterable comes directly out of the context and will
@@ -250,43 +251,43 @@ class NamingContext {
     constructor(rootNamespaces) {
         this._names = new Map();
         this._namedsForName = new Map();
-        this.isReadyToBeNamed = (named) => {
-            if (this._names.has(named))
-                return false;
-            return named.dependencies.every((n) => this._names.has(n));
-        };
-        this.isConflicting = (namedNamespace, proposed) => {
-            const namedsForProposed = this._namedsForName.get(proposed);
-            // If the name is not assigned at all, there is no conflict.
-            if (namedsForProposed === undefined)
-                return false;
-            // The name is assigned, but it might still not be forbidden.
-            for (const n of namedsForProposed) {
-                if (namedNamespace.members.has(n) || namedNamespace.forbiddenNameds.has(n)) {
-                    return true;
-                }
-            }
-            return false;
-        };
-        this.assign = (named, namedNamespace, name) => {
-            (0, Support_1.assert)(!this.names.has(named), `Name "${name}" assigned twice`);
-            (0, Support_1.assert)(!this.isConflicting(namedNamespace, name), `Assigned name "${name}" conflicts`);
-            this._names.set(named, name);
-            let namedsForName = this._namedsForName.get(name);
-            if (namedsForName === undefined) {
-                namedsForName = new Set();
-                this._namedsForName.set(name, namedsForName);
-            }
-            namedsForName.add(named);
-        };
         this.namespaces = allNamespacesRecursively(rootNamespaces);
     }
     get names() {
         return this._names;
     }
+    isReadyToBeNamed(named) {
+        if (this._names.has(named))
+            return false;
+        return named.dependencies.every((n) => this._names.has(n));
+    }
     areForbiddensFullyNamed(namespace) {
         return (0, collection_utils_1.iterableEvery)(namespace.forbiddenNameds, n => this._names.has(n));
     }
+    isConflicting(namedNamespace, proposed) {
+        const namedsForProposed = this._namedsForName.get(proposed);
+        // If the name is not assigned at all, there is no conflict.
+        if (namedsForProposed === undefined)
+            return false;
+        // The name is assigned, but it might still not be forbidden.
+        for (const n of namedsForProposed) {
+            if (namedNamespace.members.has(n) || namedNamespace.forbiddenNameds.has(n)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    assign(named, namedNamespace, name) {
+        (0, Support_1.assert)(!this.names.has(named), `Name "${name}" assigned twice`);
+        (0, Support_1.assert)(!this.isConflicting(namedNamespace, name), `Assigned name "${name}" conflicts`);
+        this._names.set(named, name);
+        let namedsForName = this._namedsForName.get(name);
+        if (namedsForName === undefined) {
+            namedsForName = new Set();
+            this._namedsForName.set(name, namedsForName);
+        }
+        namedsForName.add(named);
+    }
 }
 // Naming algorithm
 function assignNames(rootNamespaces) {
@@ -305,7 +306,7 @@ function assignNames(rootNamespaces) {
         //    If no such namespace exists we're either done, or there's an unallowed
         //    cycle.
         const unfinishedNamespaces = (0, collection_utils_1.setFilter)(ctx.namespaces, ns => ctx.areForbiddensFullyNamed(ns));
-        const readyNamespace = (0, collection_utils_1.iterableFind)(unfinishedNamespaces, ns => (0, collection_utils_1.iterableSome)(ns.members, ctx.isReadyToBeNamed));
+        const readyNamespace = (0, collection_utils_1.iterableFind)(unfinishedNamespaces, ns => (0, collection_utils_1.iterableSome)(ns.members, member => ctx.isReadyToBeNamed(member)));
         if (readyNamespace === undefined) {
             // FIXME: Check for cycles?
             return ctx.names;
@@ -316,7 +317,7 @@ function assignNames(rootNamespaces) {
         //    members of a set propose the same name and have the same naming
         //    function.
         for (;;) {
-            const allReadyNames = (0, collection_utils_1.setFilter)(readyNamespace.members, ctx.isReadyToBeNamed);
+            const allReadyNames = (0, collection_utils_1.setFilter)(readyNamespace.members, member => ctx.isReadyToBeNamed(member));
             const minOrderName = (0, collection_utils_1.iterableMinBy)(allReadyNames, n => n.order);
             if (minOrderName === undefined)
                 break;