@swagger-api/apidom-ast 0.92.0 → 0.94.0

package/es/yaml/schemas/json/index.mjs

@@ -1,41 +1,35 @@
-import stampit from 'stampit';
 import FailsafeSchema from "../failsafe/index.mjs";
-import Boolean from "./Boolean.mjs";
-import FloatingPoint from "./FloatingPoint.mjs";
-import Integer from "./Integer.mjs";
-import Null from "./Null.mjs";
+import BooleanTag from "./Boolean.mjs";
+import FloatingPointTag from "./FloatingPoint.mjs";
+import IntegerTag from "./Integer.mjs";
+import NullTag from "./Null.mjs";
 import { YamlNodeKind } from "../../nodes/YamlTag.mjs";
 import GenericSequence from "../failsafe/GenericSequence.mjs";
 import GenericMapping from "../failsafe/GenericMapping.mjs";
-const JsonSchema = stampit(FailsafeSchema, {
-  init() {
+class JsonSchema extends FailsafeSchema {
+  constructor() {
+    super();
     /**
      * We're registering more specific tags before more generic ones from Failsafe schema.
      */
-    this.registerTag(Boolean(), true);
-    this.registerTag(FloatingPoint(), true);
-    this.registerTag(Integer(), true);
-    this.registerTag(Null(), true);
-  },
-  methods: {
-    toSpecificTagName(node) {
-      // @ts-ignore
-      let specificTagName = FailsafeSchema.compose.methods.toSpecificTagName.call(this, node);
-      if (specificTagName === '?') {
-        if (node.tag.vkind === YamlNodeKind.Sequence) {
-          // @ts-ignore
-          specificTagName = GenericSequence.uri;
-        } else if (node.tag.kind === YamlNodeKind.Mapping) {
-          // @ts-ignore
-          specificTagName = GenericMapping.uri;
-        } else if (node.tag.kind === YamlNodeKind.Scalar) {
-          // @ts-ignore
-          const foundTag = this.tags.find(tag => tag.test(node));
-          specificTagName = (foundTag === null || foundTag === void 0 ? void 0 : foundTag.tag) || '?';
-        }
+    this.registerTag(new BooleanTag(), true);
+    this.registerTag(new FloatingPointTag(), true);
+    this.registerTag(new IntegerTag(), true);
+    this.registerTag(new NullTag(), true);
+  }
+  toSpecificTagName(node) {
+    let specificTagName = super.toSpecificTagName(node);
+    if (specificTagName === '?') {
+      if (node.tag.vkind === YamlNodeKind.Sequence) {
+        specificTagName = GenericSequence.uri;
+      } else if (node.tag.kind === YamlNodeKind.Mapping) {
+        specificTagName = GenericMapping.uri;
+      } else if (node.tag.kind === YamlNodeKind.Scalar) {
+        const foundTag = this.tags.find(tag => tag.test(node));
+        specificTagName = (foundTag === null || foundTag === void 0 ? void 0 : foundTag.tag) || '?';
       }
-      return specificTagName;
     }
+    return specificTagName;
   }
-});
+}
 export default JsonSchema;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swagger-api/apidom-ast",
-  "version": "0.92.0",
+  "version": "0.94.0",
   "description": "Tools necessary for parsing stage of ApiDOM, specifically for syntactic analysis.",
   "publishConfig": {
     "access": "public",
@@ -42,11 +42,10 @@
   "homepage": "https://github.com/swagger-api/apidom#readme",
   "dependencies": {
     "@babel/runtime-corejs3": "^7.20.7",
-    "@swagger-api/apidom-error": "^0.92.0",
+    "@swagger-api/apidom-error": "^0.94.0",
     "@types/ramda": "~0.29.6",
     "ramda": "~0.29.1",
     "ramda-adjunct": "^4.1.1",
-    "stampit": "^4.3.2",
     "unraw": "^3.0.0"
   },
   "files": [
@@ -59,5 +58,5 @@
     "README.md",
     "CHANGELOG.md"
   ],
-  "gitHead": "c7a45ee8d68ac82ac2ab93ebb639a95ced1d6e86"
+  "gitHead": "ad476d69176bc6246acad271c435fe3cfcdcd52c"
 }

package/types/dist.d.ts

@@ -1,115 +1,158 @@
-import stampit from 'stampit';
 import { ApiDOMStructuredError, ApiDOMErrorOptions } from '@swagger-api/apidom-error';
 
-interface Point {
-    type: 'point';
-    row: number | null;
-    column: number | null;
-    char: number | null;
+interface PointOptions {
+    readonly row: number;
+    readonly column: number;
+    readonly char: number;
 }
-declare const Point: stampit.Stamp<Point>;
-interface Position extends Node {
-    type: 'position';
-    start: Point | null;
-    end: Point | null;
+declare class Point {
+    static readonly type: string;
+    readonly type: string;
+    readonly row: number;
+    readonly column: number;
+    readonly char: number;
+    constructor({ row, column, char }: PointOptions);
+}
+interface PositionOptions {
+    readonly start: Point;
+    readonly end: Point;
+}
+declare class Position {
+    static readonly type: string;
+    readonly type: string;
+    readonly start: Point;
+    readonly end: Point;
+    constructor({ start, end }: PositionOptions);
 }
-declare const Position: stampit.Stamp<Position>;
 
-interface Node$1 {
-    type: string | null;
-    isMissing: boolean;
+interface NodeOptions {
+    readonly children?: unknown[];
+    readonly position?: Position;
+    readonly isMissing?: boolean;
+}
+declare class Node {
+    static readonly type: string;
+    readonly type: string;
+    readonly isMissing: boolean;
     children: unknown[];
-    position: Position | null;
+    position?: Position;
+    constructor({ children, position, isMissing }?: NodeOptions);
+    clone(): Node;
 }
-declare const Node$1: stampit.Stamp<Node$1>;
 
-type JsonNode = Node$1;
-declare const JsonNode: stampit.Stamp<JsonNode>;
-
-interface JsonDocument extends JsonNode {
-    child: unknown | null;
+declare class JsonNode extends Node {
 }
-declare const JsonDocument: stampit.Stamp<JsonDocument>;
 
-type JsonObject = JsonNode;
-declare const JsonObject: stampit.Stamp<JsonObject>;
+declare class JsonDocument extends JsonNode {
+    static readonly type = "document";
+    get child(): unknown;
+}
 
-interface JsonString extends JsonNode {
-    value: string;
+declare class JsonString extends JsonNode {
+    static readonly type: string;
+    get value(): string;
 }
-declare const JsonString: stampit.Stamp<JsonString>;
 
-type JsonKey = JsonString;
-declare const JsonKey: stampit.Stamp<JsonKey>;
+declare class JsonKey extends JsonString {
+    static readonly type = "key";
+}
 
-interface JsonProperty extends JsonNode {
-    key: JsonKey;
-    value: unknown;
+interface JsonValueOptions extends NodeOptions {
+    value: string;
+}
+declare class JsonValue$1 extends JsonNode {
+    static readonly type: string;
+    readonly value: string;
+    constructor({ value, ...rest }: JsonValueOptions);
 }
-declare const JsonProperty: stampit.Stamp<JsonProperty>;
 
-type JsonArray = JsonNode;
-declare const JsonArray: stampit.Stamp<JsonArray>;
+declare class JsonFalse extends JsonValue$1 {
+    static readonly type = "false";
+}
 
-interface JsonValue extends JsonNode {
-    value: unknown;
+declare class JsonTrue extends JsonValue$1 {
+    static readonly type = "true";
 }
-declare const JsonValue: stampit.Stamp<JsonValue>;
 
-type JsonStringContent = JsonValue;
-declare const JsonStringContent: stampit.Stamp<JsonStringContent>;
+declare class JsonNull extends JsonValue$1 {
+    static readonly type = "null";
+}
 
-type JsonEscapeSequence = JsonValue;
-declare const JsonEscapeSequence: stampit.Stamp<JsonEscapeSequence>;
+declare class JsonNumber extends JsonValue$1 {
+    static readonly type = "number";
+}
 
-type JsonNumber = JsonValue;
-declare const JsonNumber: stampit.Stamp<JsonNumber>;
+declare class JsonArray extends JsonNode {
+    static readonly type = "array";
+    get items(): unknown[];
+}
 
-type JsonTrue = JsonValue;
-declare const JsonTrue: stampit.Stamp<JsonTrue>;
+type JsonValue = JsonFalse | JsonTrue | JsonNull | JsonNumber | JsonString | JsonArray | JsonObject;
+declare class JsonProperty extends JsonNode {
+    static readonly type = "property";
+    get key(): JsonKey | undefined;
+    get value(): JsonValue | undefined;
+}
 
-type JsonFalse = JsonValue;
-declare const JsonFalse: stampit.Stamp<JsonFalse>;
+declare class JsonObject extends JsonNode {
+    static readonly type = "object";
+    get properties(): Array<JsonProperty>;
+}
 
-type JsonNull = JsonValue;
-declare const JsonNull: stampit.Stamp<JsonNull>;
+declare class JsonStringContent extends JsonValue$1 {
+    static readonly type = "stringContent";
+}
 
-declare const isDocument$1: (node: any) => boolean;
-declare const isString: (node: any) => boolean;
-declare const isFalse: (node: any) => boolean;
-declare const isTrue: (node: any) => boolean;
-declare const isNull: (node: any) => boolean;
-declare const isNumber: (node: any) => boolean;
-declare const isArray: (node: any) => boolean;
-declare const isObject: (node: any) => boolean;
-declare const isStringContent: (node: any) => boolean;
-declare const isEscapeSequence: (node: any) => boolean;
-declare const isProperty: (node: any) => boolean;
-declare const isKey: (node: any) => boolean;
+declare class JsonEscapeSequence extends JsonValue$1 {
+    static readonly type = "escapeSequence";
+}
 
-interface YamlAlias extends Node$1 {
-    type: 'alias';
-    content: string | null;
+declare const isDocument$1: (node: unknown) => node is JsonDocument;
+declare const isString: (node: unknown) => node is JsonString;
+declare const isFalse: (node: unknown) => node is JsonFalse;
+declare const isTrue: (node: unknown) => node is JsonTrue;
+declare const isNull: (node: unknown) => node is JsonNull;
+declare const isNumber: (node: unknown) => node is JsonNumber;
+declare const isArray: (node: unknown) => node is JsonArray;
+declare const isObject: (node: unknown) => node is JsonObject;
+declare const isStringContent: (node: unknown) => node is JsonStringContent;
+declare const isEscapeSequence: (node: unknown) => node is JsonEscapeSequence;
+declare const isProperty: (node: unknown) => node is JsonProperty;
+declare const isKey: (node: unknown) => node is JsonKey;
+
+interface YamlAliasOptions extends NodeOptions {
+    readonly content: string;
+}
+declare class YamlAlias extends Node {
+    static readonly type = "alias";
+    readonly content: string;
+    constructor({ content, ...rest }: YamlAliasOptions);
 }
-declare const YamlAlias: stampit.Stamp<YamlAlias>;
 
 declare enum YamlNodeKind {
     Scalar = "Scalar",
     Sequence = "Sequence",
     Mapping = "Mapping"
 }
-interface YamlTag extends Node$1 {
-    type: 'tag';
-    explicitName: string;
-    kind: YamlNodeKind;
+interface YamlTagOptions extends NodeOptions {
+    readonly explicitName: string;
+    readonly kind: YamlNodeKind;
+}
+declare class YamlTag extends Node {
+    static readonly type = "tag";
+    readonly explicitName: string;
+    readonly kind: YamlNodeKind;
+    constructor({ explicitName, kind, ...rest }: YamlTagOptions);
 }
-declare const YamlTag: stampit.Stamp<YamlTag>;
 
-interface YamlAnchor extends Node$1 {
-    type: 'anchor';
-    name: string | null;
+interface YamlAnchorOptions extends NodeOptions {
+    readonly name: string;
+}
+declare class YamlAnchor extends Node {
+    static readonly type = "anchor";
+    readonly name: string;
+    constructor({ name, ...rest }: YamlAnchorOptions);
 }
-declare const YamlAnchor: stampit.Stamp<YamlAnchor>;
 
 declare enum YamlStyle {
     Plain = "Plain",
@@ -126,98 +169,126 @@ declare enum YamlStyleGroup {
     Flow = "Flow",
     Block = "Block"
 }
-interface YamlStyleModel {
-    styleGroup: YamlStyleGroup | null;
-    style: YamlStyle | null;
-}
-declare const YamlStyleModel: stampit.Stamp<YamlStyleModel>;
 
-interface YamlNode extends Node$1 {
-    anchor: YamlAnchor | null;
-    tag: YamlTag | null;
-    style: YamlStyle;
-    styleGroup: YamlStyleGroup;
+interface YamlNodeOptions extends NodeOptions {
+    readonly anchor?: YamlAnchor;
+    readonly tag?: YamlTag;
+    readonly style: YamlStyle;
+    readonly styleGroup: YamlStyleGroup;
+}
+declare class YamlNode extends Node {
+    readonly anchor?: YamlAnchor;
+    readonly tag?: YamlTag;
+    readonly style: YamlStyle;
+    readonly styleGroup: YamlStyleGroup;
+    constructor({ anchor, tag, style, styleGroup, ...rest }: YamlNodeOptions);
 }
-declare const YamlNode: stampit.Stamp<YamlNode>;
 
-type YamlCollection = YamlNode;
-declare const YamlCollection: stampit.Stamp<YamlCollection>;
+declare class YamlCollection extends YamlNode {
+}
 
-interface YamlComment extends Node$1 {
-    type: 'comment';
-    content: string | null;
+interface YamlCommentOptions extends NodeOptions {
+    readonly content: string;
+}
+declare class YamlComment extends Node {
+    static readonly type = "comment";
+    readonly content: string;
+    constructor({ content, ...rest }: YamlCommentOptions);
 }
-declare const YamlComment: stampit.Stamp<YamlComment>;
 
 interface YamlDirectiveParameters {
-    version: string | null;
-    handle: string | null;
-    prefix: string | null;
+    readonly version?: string;
+    readonly handle?: string;
+    readonly prefix?: string;
+}
+interface YamlDirectiveOptions extends NodeOptions {
+    readonly name?: string;
+    readonly parameters: YamlDirectiveParameters;
+}
+declare class YamlDirective extends Node {
+    static readonly type = "directive";
+    readonly name?: string;
+    readonly parameters: YamlDirectiveParameters;
+    constructor({ name, parameters, ...rest }: YamlDirectiveOptions);
+}
+
+declare class YamlDocument extends Node {
+    static readonly type = "document";
+}
+
+interface YamlKeyValuePairOptions extends NodeOptions {
+    readonly styleGroup: YamlStyleGroup;
 }
-interface YamlDirective extends Node$1 {
-    type: 'directive';
-    name: string | null;
-    parameters: YamlDirectiveParameters;
+declare class YamlKeyValuePair extends Node {
+    static readonly type = "keyValuePair";
+    readonly styleGroup: YamlStyleGroup;
+    constructor({ styleGroup, ...rest }: YamlKeyValuePairOptions);
 }
-declare const YamlDirective: stampit.Stamp<YamlDirective>;
 
-interface YamlDocument extends Node$1 {
-    type: 'document';
+declare class YamlMapping extends YamlCollection {
+    static readonly type = "mapping";
 }
-declare const YamlDocument: stampit.Stamp<YamlDocument>;
 
-interface YamlScalar extends YamlNode {
-    type: 'scalar';
-    format: string | null;
-    text: string;
-    readonly content: string | null;
+interface YamlScalarOptions extends YamlNodeOptions {
+    readonly content: string;
+}
+declare class YamlScalar extends YamlNode {
+    static readonly type = "scalar";
+    readonly content: string;
+    constructor({ content, ...rest }: YamlScalarOptions);
 }
-declare const YamlScalar: stampit.Stamp<YamlScalar>;
 
-interface YamlKeyValuePair extends Node$1, YamlStyleModel {
-    type: 'keyValuePair';
-    readonly key: YamlScalar;
-    readonly value: any;
+declare class YamlSequence extends YamlCollection {
+    static readonly type = "sequence";
 }
-declare const YamlKeyValuePair: stampit.Stamp<YamlKeyValuePair>;
 
-interface YamlMapping extends YamlCollection {
-    type: 'mapping';
-    readonly content: Array<YamlKeyValuePair>;
+declare class YamlStream extends Node {
+    static readonly type = "stream";
 }
-declare const YamlMapping: stampit.Stamp<YamlMapping>;
 
-interface YamlSequence extends YamlCollection {
-    type: 'sequence';
-    readonly content: Array<YamlSequence | YamlMapping | YamlScalar | YamlAlias>;
+declare class FailsafeSchema {
+    tags: any[];
+    tagDirectives: YamlDirective[];
+    constructor();
+    toSpecificTagName(node: any): string;
+    registerTagDirective(tagDirective: YamlDirective): void;
+    registerTag(tag: any, beginning?: boolean): this;
+    overrideTag(tag: any): this;
+    resolve(node: any): any;
 }
-declare const YamlSequence: stampit.Stamp<YamlSequence>;
 
-interface YamlStream extends Node$1 {
-    type: 'stream';
-    readonly content: Array<YamlDocument | YamlComment>;
-    children: Array<YamlDocument>;
+declare class JsonSchema extends FailsafeSchema {
+    constructor();
+    toSpecificTagName(node: any): any;
 }
-declare const YamlStream: stampit.Stamp<YamlStream>;
 
-declare const FailsafeSchema: stampit.Stamp<any>;
+declare class ReferenceManager {
+    addAnchor(node: YamlNode): void;
+    resolveAlias(alias: YamlAlias): YamlScalar;
+}
 
-declare const JsonSchema: stampit.Stamp<any>;
+declare const isStream: (node: unknown) => node is YamlStream;
+declare const isDocument: (node: unknown) => node is YamlDocument;
+declare const isMapping: (node: unknown) => node is YamlMapping;
+declare const isSequence: (node: unknown) => node is YamlSequence;
+declare const isKeyValuePair: (node: unknown) => node is YamlKeyValuePair;
+declare const isTag: (node: unknown) => node is YamlTag;
+declare const isAnchor: (node: unknown) => node is YamlAnchor;
+declare const isScalar: (node: unknown) => node is YamlScalar;
+declare const isAlias: (node: unknown) => node is YamlAlias;
+declare const isDirective: (node: unknown) => node is YamlDirective;
+declare const isComment: (node: unknown) => node is YamlComment;
+
+declare class YamlError extends ApiDOMStructuredError {
+}
 
-declare const isStream: (node: any) => boolean;
-declare const isDocument: (node: any) => boolean;
-declare const isMapping: (node: any) => boolean;
-declare const isSequence: (node: any) => boolean;
-declare const isKeyValuePair: (node: any) => boolean;
-declare const isTag: (node: any) => boolean;
-declare const isScalar: (node: any) => boolean;
-declare const isAlias: (node: any) => boolean;
-declare const isDirective: (node: any) => boolean;
+declare class YamlReferenceError extends YamlError {
+}
 
-declare class YamlSchemaError extends ApiDOMStructuredError {
+declare class YamlSchemaError extends YamlError {
 }
 
-interface YamlTagErrorOptions<T extends Node$1 = Node$1> extends ApiDOMErrorOptions {
+interface YamlTagErrorOptions<T extends Node = Node> extends ApiDOMErrorOptions {
     readonly specificTagName: string;
     readonly explicitTagName: string;
     readonly tagKind: string;
@@ -235,28 +306,35 @@ declare class YamlTagError extends YamlSchemaError {
     constructor(message?: string, structuredOptions?: YamlTagErrorOptions);
 }
 
-interface Literal extends Node$1 {
-    type: 'literal';
-    value: unknown;
+interface LiteralOptions extends NodeOptions {
+    readonly value?: unknown;
+}
+declare class Literal extends Node {
+    static readonly type: string;
+    readonly value: unknown;
+    constructor({ value, ...rest }?: LiteralOptions);
 }
-declare const Literal: stampit.Stamp<Literal>;
 
-interface Error extends Node$1 {
-    value: unknown;
-    isUnexpected: boolean;
+interface ErrorOptions extends NodeOptions {
+    readonly value?: unknown;
+    readonly isUnexpected?: boolean;
+}
+declare class Error extends Node {
+    static readonly type: string;
+    readonly value: unknown;
+    readonly isUnexpected: boolean;
+    constructor({ value, isUnexpected, ...rest }?: ErrorOptions);
 }
-declare const Error: stampit.Stamp<Error>;
 
-interface ParseResult extends Node$1 {
-    type: 'parseResult';
-    rootNode: unknown;
+declare class ParseResult extends Node {
+    static readonly type: string;
+    get rootNode(): unknown;
 }
-declare const ParseResult: stampit.Stamp<ParseResult>;
 
-declare const isLiteral: (node: any) => boolean;
-declare const isPosition: (node: any) => boolean;
-declare const isPoint: (node: any) => boolean;
-declare const isParseResult: (node: any) => boolean;
+declare const isLiteral: (node: unknown) => node is Literal;
+declare const isPosition: (node: unknown) => node is Position;
+declare const isPoint: (node: unknown) => node is Point;
+declare const isParseResult: (node: unknown) => node is ParseResult;
 
 /**
  * SPDX-FileCopyrightText: Copyright (c) GraphQL Contributors
@@ -388,4 +466,4 @@ declare const visit: (root: any, visitor: any, { keyMap, state, breakSymbol, del
     detectCycles?: boolean | undefined;
 }) => any;
 
-export { BREAK, Error, JsonArray, JsonDocument, JsonEscapeSequence, JsonFalse, JsonKey, JsonNode, JsonNull, JsonNumber, JsonObject, JsonProperty, JsonString, JsonStringContent, JsonTrue, JsonValue, Literal, ParseResult, Point, Position, YamlAlias, YamlAnchor, YamlCollection, YamlComment, YamlDirective, YamlDocument, FailsafeSchema as YamlFailsafeSchema, JsonSchema as YamlJsonSchema, YamlKeyValuePair, YamlMapping, YamlNode, YamlNodeKind, YamlScalar, YamlSchemaError, YamlSequence, YamlStream, YamlStyle, YamlStyleGroup, YamlTag, YamlTagError, type YamlTagErrorOptions, cloneNode, getNodeType, getVisitFn, isArray as isJsonArray, isDocument$1 as isJsonDocument, isEscapeSequence as isJsonEscapeSequence, isFalse as isJsonFalse, isKey as isJsonKey, isNull as isJsonNull, isNumber as isJsonNumber, isObject as isJsonObject, isProperty as isJsonProperty, isString as isJsonString, isStringContent as isJsonStringContent, isTrue as isJsonTrue, isLiteral, isNode, isParseResult, isPoint, isPosition, isAlias as isYamlAlias, isDirective as isYamlDirective, isDocument as isYamlDocument, isKeyValuePair as isYamlKeyValuePair, isMapping as isYamlMapping, isScalar as isYamlScalar, isSequence as isYamlSequence, isStream as isYamlStream, isTag as isYamlTag, mergeAll as mergeAllVisitors, visit };
+export { BREAK, Error, JsonArray, JsonDocument, JsonEscapeSequence, JsonFalse, JsonKey, JsonNode, JsonNull, JsonNumber, JsonObject, JsonProperty, JsonString, JsonStringContent, JsonTrue, JsonValue$1 as JsonValue, Literal, ParseResult, Point, Position, YamlAlias, YamlAnchor, YamlCollection, YamlComment, YamlDirective, YamlDocument, YamlError, FailsafeSchema as YamlFailsafeSchema, JsonSchema as YamlJsonSchema, YamlKeyValuePair, YamlMapping, YamlNode, YamlNodeKind, YamlReferenceError, ReferenceManager as YamlReferenceManager, YamlScalar, YamlSchemaError, YamlSequence, YamlStream, YamlStyle, YamlStyleGroup, YamlTag, YamlTagError, type YamlTagErrorOptions, cloneNode, getNodeType, getVisitFn, isArray as isJsonArray, isDocument$1 as isJsonDocument, isEscapeSequence as isJsonEscapeSequence, isFalse as isJsonFalse, isKey as isJsonKey, isNull as isJsonNull, isNumber as isJsonNumber, isObject as isJsonObject, isProperty as isJsonProperty, isString as isJsonString, isStringContent as isJsonStringContent, isTrue as isJsonTrue, isLiteral, isNode, isParseResult, isPoint, isPosition, isAlias as isYamlAlias, isAnchor as isYamlAnchor, isComment as isYamlComment, isDirective as isYamlDirective, isDocument as isYamlDocument, isKeyValuePair as isYamlKeyValuePair, isMapping as isYamlMapping, isScalar as isYamlScalar, isSequence as isYamlSequence, isStream as isYamlStream, isTag as isYamlTag, mergeAll as mergeAllVisitors, visit };