@abapify/aclass 0.0.0 → 0.4.6

package/dist/index.d.mts

@@ -0,0 +1,359 @@
+import { ILexingError, IRecognitionException, IToken, Lexer } from "chevrotain";
+//#region src/errors.d.ts
+interface ParseError {
+  severity: 'error' | 'warning';
+  message: string;
+  line: number;
+  column: number;
+  offset: number;
+  length: number;
+}
+declare function fromLexError(err: ILexingError): ParseError;
+declare function fromParseError(err: IRecognitionException): ParseError;
+//#endregion
+//#region src/ast.d.ts
+/**
+ * Typed AST for `@abapify/aclass` — ABAP OO structural parser.
+ *
+ * Covers class / interface declarations, sections, and member
+ * declarations. Method-implementation bodies are preserved as opaque
+ * source slices; their statements are NOT modelled.
+ */
+interface SourceSpan {
+  readonly startOffset: number;
+  readonly endOffset: number;
+  readonly startLine: number;
+  readonly startColumn: number;
+}
+type Visibility = 'public' | 'protected' | 'private';
+type TypeRef = BuiltinTypeRef | NamedTypeRef | RefToTypeRef | TableTypeRef;
+interface BuiltinTypeRef {
+  readonly kind: 'BuiltinTypeRef';
+  readonly name: string;
+  readonly source: string;
+}
+interface NamedTypeRef {
+  readonly kind: 'NamedTypeRef';
+  readonly name: string;
+  readonly source: string;
+}
+interface RefToTypeRef {
+  readonly kind: 'RefToTypeRef';
+  readonly target: TypeRef;
+  readonly source: string;
+}
+type TableKind = 'standard' | 'sorted' | 'hashed';
+interface TableTypeRef {
+  readonly kind: 'TableTypeRef';
+  readonly tableKind: TableKind;
+  readonly row: TypeRef;
+  readonly keyClause: string;
+  readonly source: string;
+}
+interface MethodParam {
+  readonly kind: 'MethodParam';
+  readonly name: string;
+  readonly type: TypeRef;
+  readonly isValue: boolean;
+  readonly isOptional: boolean;
+  readonly defaultValue?: string;
+  readonly abapDoc?: readonly string[];
+  readonly span: SourceSpan;
+}
+type AbapDefinition = ClassDef | ClassImpl | InterfaceDef;
+interface AbapSourceFile {
+  readonly kind: 'AbapSourceFile';
+  readonly source: string;
+  readonly definitions: readonly AbapDefinition[];
+}
+interface ClassDef {
+  readonly kind: 'ClassDef';
+  readonly name: string;
+  readonly abapDoc?: readonly string[];
+  readonly isFinal: boolean;
+  readonly isAbstract: boolean;
+  readonly isForTesting: boolean;
+  readonly createVisibility: Visibility;
+  readonly superClass?: string;
+  readonly sections: readonly Section[];
+  readonly span: SourceSpan;
+}
+interface Section {
+  readonly kind: 'Section';
+  readonly visibility: Visibility;
+  readonly members: readonly ClassMember[];
+  readonly span: SourceSpan;
+}
+type ClassMember = MethodDecl | AttributeDecl | TypeDecl | ConstantDecl | EventDecl | InterfaceStmt | AliasDecl | RawMember;
+interface MethodDecl {
+  readonly kind: 'MethodDecl';
+  readonly name: string;
+  readonly abapDoc?: readonly string[];
+  readonly isClassMethod: boolean;
+  readonly isAbstract: boolean;
+  readonly isFinal: boolean;
+  readonly isRedefinition: boolean;
+  readonly isForTesting: boolean;
+  readonly importing: readonly MethodParam[];
+  readonly exporting: readonly MethodParam[];
+  readonly changing: readonly MethodParam[];
+  readonly returning?: MethodParam;
+  readonly raising: readonly string[];
+  readonly span: SourceSpan;
+}
+interface AttributeDecl {
+  readonly kind: 'AttributeDecl';
+  readonly name: string;
+  readonly abapDoc?: readonly string[];
+  readonly isClassData: boolean;
+  readonly isReadOnly: boolean;
+  readonly type: TypeRef;
+  readonly span: SourceSpan;
+}
+interface TypeDecl {
+  readonly kind: 'TypeDecl';
+  readonly name: string;
+  readonly abapDoc?: readonly string[];
+  readonly shape: TypeDeclShape;
+  readonly span: SourceSpan;
+}
+type TypeDeclShape = {
+  readonly kind: 'alias';
+  readonly type: TypeRef;
+} | {
+  readonly kind: 'structure';
+  readonly fields: readonly StructureField[];
+};
+interface StructureField {
+  readonly kind: 'StructureField';
+  readonly name: string;
+  readonly type: TypeRef;
+  readonly abapDoc?: readonly string[];
+  readonly span: SourceSpan;
+}
+interface ConstantDecl {
+  readonly kind: 'ConstantDecl';
+  readonly name: string;
+  readonly type: TypeRef;
+  readonly value: string;
+  readonly abapDoc?: readonly string[];
+  readonly span: SourceSpan;
+}
+interface EventDecl {
+  readonly kind: 'EventDecl';
+  readonly name: string;
+  readonly abapDoc?: readonly string[];
+  /** True when the declaration is `CLASS-EVENTS`, false for instance-level `EVENTS`. */
+  readonly isClassEvent: boolean;
+  /**
+   * Parameters declared after `EXPORTING`. Each entry is a `MethodParam`
+   * for shape consistency with `MethodDecl.importing` / .exporting. Events
+   * only support `VALUE(...) TYPE <ref>` in practice; other slots are
+   * always empty for events.
+   */
+  readonly exporting: readonly MethodParam[];
+  readonly span: SourceSpan;
+}
+interface InterfaceStmt {
+  readonly kind: 'InterfaceStmt';
+  readonly name: string;
+  readonly abapDoc?: readonly string[];
+  readonly span: SourceSpan;
+}
+interface AliasDecl {
+  readonly kind: 'AliasDecl';
+  readonly name: string;
+  readonly target: string;
+  readonly abapDoc?: readonly string[];
+  readonly span: SourceSpan;
+}
+interface RawMember {
+  readonly kind: 'RawMember';
+  readonly source: string;
+  readonly abapDoc?: readonly string[];
+  readonly span: SourceSpan;
+}
+interface ClassImpl {
+  readonly kind: 'ClassImpl';
+  readonly name: string;
+  readonly methods: readonly MethodImpl[];
+  readonly span: SourceSpan;
+}
+interface MethodImpl {
+  readonly kind: 'MethodImpl';
+  readonly name: string;
+  readonly body: string;
+  readonly bodySpan: SourceSpan;
+  readonly span: SourceSpan;
+}
+interface InterfaceDef {
+  readonly kind: 'InterfaceDef';
+  readonly name: string;
+  readonly abapDoc?: readonly string[];
+  readonly isPublic: boolean;
+  readonly members: readonly ClassMember[];
+  readonly span: SourceSpan;
+}
+//#endregion
+//#region src/parser.d.ts
+interface ParseResult {
+  readonly ast: AbapSourceFile;
+  readonly errors: readonly ParseError[];
+}
+/**
+ * Parse an ABAP OO source file into a typed AST plus any diagnostics.
+ * Returns a `{ ast, errors }` shape; never throws for malformed input.
+ */
+declare function parse(source: string): ParseResult;
+declare namespace tokens_d_exports {
+  export { ABAPDocLine, Abstract, AclassLexer, Aliases, Ampersand, Arrow, As, At, BacktickLiteral, Begin, Changing, Class, ClassData, ClassEvents, ClassMethods, Colon, ColonColon, Comma, Constants, Create, Data, Default, Deferred, Definition, Dot, Duration, Empty, End, EndClass, EndInterface, EndMethod, Eq, Events, Exporting, FatArrow, Final, For, From, Gt, Hash, Hashed, Identifier, Implementation, Importing, Inheriting, IntegerLiteral, Interface, Interfaces, Key, LBrace, LBracket, LParen, Level, Like, LineComment, Load, Lt, Method, Methods, Minus, Newline, NonUnique, Of, Optional, Pipe, Plus, Private, Protected, Public, Question, RBrace, RBracket, RParen, Raising, ReadOnly, Redefinition, Ref, Returning, Risk, Section$1 as Section, Slash, Sorted, Standard, Star, StarComment, StringLiteral, Table, Testing, Tilde, To, Type, Types, Unique, Value, WhiteSpace, With, allTokens };
+}
+declare const WhiteSpace: import("chevrotain").TokenType;
+declare const Newline: import("chevrotain").TokenType;
+/**
+ * ABAPDoc line: `"! …` up to end of line. MUST come before LineComment
+ * because `"!` is a prefix of `"`.
+ */
+declare const ABAPDocLine: import("chevrotain").TokenType;
+/** Regular line comment: `" …` up to end of line. */
+declare const LineComment: import("chevrotain").TokenType;
+declare const StarComment: import("chevrotain").TokenType;
+/** Single-quoted ABAP text literal: `'...'` with doubled `''` for escaping. */
+declare const StringLiteral: import("chevrotain").TokenType;
+/** Backtick string literal: \`...\`. */
+declare const BacktickLiteral: import("chevrotain").TokenType;
+declare const IntegerLiteral: import("chevrotain").TokenType;
+/**
+ * ABAP identifier: starts with letter or underscore; may contain letters,
+ * digits, underscores, slash (for namespaces like `/ui2/cl_json`), and
+ * tilde (for qualified names like `zif_foo~method`) — but tilde is
+ * reserved for qualified references, so at the lexer level we only allow
+ * the "simple" form here. Qualified `~` and `=>` are handled in the
+ * parser via separate tokens.
+ *
+ * Note: the `=>` operator (static scope) is tokenised as a distinct
+ * symbol, not as part of the identifier.
+ */
+declare const Identifier: import("chevrotain").TokenType;
+declare const ClassMethods: import("chevrotain").TokenType;
+declare const ClassData: import("chevrotain").TokenType;
+declare const ClassEvents: import("chevrotain").TokenType;
+declare const NonUnique: import("chevrotain").TokenType;
+declare const Class: import("chevrotain").TokenType;
+declare const Interfaces: import("chevrotain").TokenType;
+declare const Interface: import("chevrotain").TokenType;
+declare const EndClass: import("chevrotain").TokenType;
+declare const EndInterface: import("chevrotain").TokenType;
+declare const EndMethod: import("chevrotain").TokenType;
+declare const Definition: import("chevrotain").TokenType;
+declare const Implementation: import("chevrotain").TokenType;
+declare const Deferred: import("chevrotain").TokenType;
+declare const Load: import("chevrotain").TokenType;
+declare const Public: import("chevrotain").TokenType;
+declare const Protected: import("chevrotain").TokenType;
+declare const Private: import("chevrotain").TokenType;
+declare const Section$1: import("chevrotain").TokenType;
+declare const Methods: import("chevrotain").TokenType;
+declare const Method: import("chevrotain").TokenType;
+declare const Data: import("chevrotain").TokenType;
+declare const Types: import("chevrotain").TokenType;
+declare const Constants: import("chevrotain").TokenType;
+declare const Events: import("chevrotain").TokenType;
+declare const Aliases: import("chevrotain").TokenType;
+declare const Inheriting: import("chevrotain").TokenType;
+declare const From: import("chevrotain").TokenType;
+declare const For: import("chevrotain").TokenType;
+declare const Testing: import("chevrotain").TokenType;
+declare const Risk: import("chevrotain").TokenType;
+declare const Level: import("chevrotain").TokenType;
+declare const Duration: import("chevrotain").TokenType;
+declare const Final: import("chevrotain").TokenType;
+declare const Abstract: import("chevrotain").TokenType;
+declare const Create: import("chevrotain").TokenType;
+declare const Importing: import("chevrotain").TokenType;
+declare const Exporting: import("chevrotain").TokenType;
+declare const Changing: import("chevrotain").TokenType;
+declare const Returning: import("chevrotain").TokenType;
+declare const Raising: import("chevrotain").TokenType;
+declare const Value: import("chevrotain").TokenType;
+declare const Optional: import("chevrotain").TokenType;
+declare const Default: import("chevrotain").TokenType;
+declare const Redefinition: import("chevrotain").TokenType;
+declare const Type: import("chevrotain").TokenType;
+declare const Ref: import("chevrotain").TokenType;
+declare const To: import("chevrotain").TokenType;
+declare const Like: import("chevrotain").TokenType;
+declare const Begin: import("chevrotain").TokenType;
+declare const End: import("chevrotain").TokenType;
+declare const Of: import("chevrotain").TokenType;
+declare const Standard: import("chevrotain").TokenType;
+declare const Sorted: import("chevrotain").TokenType;
+declare const Hashed: import("chevrotain").TokenType;
+declare const Table: import("chevrotain").TokenType;
+declare const With: import("chevrotain").TokenType;
+declare const Key: import("chevrotain").TokenType;
+declare const Empty: import("chevrotain").TokenType;
+declare const Unique: import("chevrotain").TokenType;
+declare const As: import("chevrotain").TokenType;
+declare const ReadOnly: import("chevrotain").TokenType;
+/** Static scope operator: `=>` */
+declare const FatArrow: import("chevrotain").TokenType;
+/** Instance member operator: `->` */
+declare const Arrow: import("chevrotain").TokenType;
+/** Component selector inside generic reference: `::` (rare, reserved). */
+declare const ColonColon: import("chevrotain").TokenType;
+declare const Dot: import("chevrotain").TokenType;
+declare const Comma: import("chevrotain").TokenType;
+declare const Colon: import("chevrotain").TokenType;
+declare const Tilde: import("chevrotain").TokenType;
+declare const LParen: import("chevrotain").TokenType;
+declare const RParen: import("chevrotain").TokenType;
+declare const LBracket: import("chevrotain").TokenType;
+declare const RBracket: import("chevrotain").TokenType;
+declare const Eq: import("chevrotain").TokenType;
+declare const Hash: import("chevrotain").TokenType;
+declare const Pipe: import("chevrotain").TokenType;
+declare const LBrace: import("chevrotain").TokenType;
+declare const RBrace: import("chevrotain").TokenType;
+declare const Plus: import("chevrotain").TokenType;
+declare const Minus: import("chevrotain").TokenType;
+declare const Star: import("chevrotain").TokenType;
+declare const Slash: import("chevrotain").TokenType;
+declare const Lt: import("chevrotain").TokenType;
+declare const Gt: import("chevrotain").TokenType;
+declare const Question: import("chevrotain").TokenType;
+declare const At: import("chevrotain").TokenType;
+declare const Ampersand: import("chevrotain").TokenType;
+declare const allTokens: import("chevrotain").TokenType[];
+declare const AclassLexer: Lexer;
+//#endregion
+//#region src/lex.d.ts
+interface LexResult {
+  tokens: IToken[];
+  errors: ParseError[];
+}
+declare function tokenize(source: string): LexResult;
+//#endregion
+//#region src/assert.d.ts
+declare class AclassParseError extends Error {
+  readonly source: string;
+  readonly errors: readonly ParseError[];
+  constructor(fileLabel: string, errors: readonly ParseError[], source: string);
+}
+/**
+ * Throw `AclassParseError` if the source has any lex / parse errors.
+ * `fileLabel` is included in the message so CI output points at the
+ * offending file without the caller having to format it.
+ *
+ * Intended use in test suites:
+ *
+ * ```ts
+ * for (const f of generated) {
+ *   assertCleanParse(readFileSync(f, 'utf8'), f);
+ * }
+ * ```
+ */
+declare function assertCleanParse(source: string, fileLabel?: string): void;
+//#endregion
+export { AbapDefinition, AbapSourceFile, AclassLexer, AclassParseError, AliasDecl, AttributeDecl, BuiltinTypeRef, ClassDef, ClassImpl, ClassMember, ConstantDecl, EventDecl, InterfaceDef, InterfaceStmt, type LexResult, MethodDecl, MethodImpl, MethodParam, NamedTypeRef, type ParseError, type ParseResult, RawMember, RefToTypeRef, Section, SourceSpan, StructureField, TableKind, TableTypeRef, TypeDecl, TypeDeclShape, TypeRef, Visibility, allTokens, assertCleanParse, fromLexError, fromParseError, parse, tokenize, tokens_d_exports as tokens };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/errors.ts","../src/ast.ts","../src/parser.ts","../src/tokens.ts","../src/lex.ts","../src/assert.ts"],"mappings":";;UASiB;EACf;EACA;EACA;EACA;EACA;EACA;;iBAGc,aAAa,KAAK,eAAe;iBAWjC,eAAe,KAAK,wBAAwB;;;;;;;;;;UCrB3C;WACN;WACA;WACA;WACA;;KAGC;KAIA,UACR,iBACA,eACA,eACA;UAEa;WACN;WACA;WACA;;UAGM;WACN;WACA;WACA;;UAGM;WACN;WACA,QAAQ;WACR;;KAGC;UAEK;WACN;WACA,WAAW;WACX,KAAK;WACL;WACA;;UAGM;WACN;WACA;WACA,MAAM;WACN;WACA;WACA;WACA;WACA,MAAM;;KAKL,iBAAiB,WAAW,YAAY;UAEnC;WACN;WACA;WACA,sBAAsB;;UAGhB;WACN;WACA;WACA;WACA;WACA;WACA;WACA,kBAAkB;WAClB;WACA,mBAAmB;WACnB,MAAM;;UAGA;WACN;WACA,YAAY;WACZ,kBAAkB;WAClB,MAAM;;KAGL,cACR,aACA,gBACA,WACA,eACA,YACA,gBACA,YACA;UAEa;WACN;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA,oBAAoB;WACpB,oBAAoB;WACpB,mBAAmB;WACnB,YAAY;WACZ;WACA,MAAM;;UAGA;WACN;WACA;WACA;WACA;WACA;WACA,MAAM;WACN,MAAM;;UAGA;WACN;WACA;WACA;WACA,OAAO;WACP,MAAM;;KAGL;WACG;WAAwB,MAAM;;WAC9B;WAA4B,iBAAiB;;UAE3C;WACN;WACA;WACA,MAAM;WACN;WACA,MAAM;;UAGA;WACN;WACA;WACA,MAAM;WACN;WACA;WACA,MAAM;;UAGA;WACN;WACA;WACA;;WAEA;;;;;;;WAOA,oBAAoB;WACpB,MAAM;;UAGA;WACN;WACA;WACA;WACA,MAAM;;UAGA;WACN;WACA;WACA;WACA;WACA,MAAM;;UAGA;WACN;WACA;WACA;WACA,MAAM;;UAGA;WACN;WACA;WACA,kBAAkB;WAClB,MAAM;;UAGA;WACN;WACA;WACA;WACA,UAAU;WACV,MAAM;;UAGA;WACN;WACA;WACA;WACA;WACA,kBAAkB;WAClB,MAAM;;;;UC5KA;WACN,KAAK;WACL,iBAAiB;;;;;;iBAOZ,MAAM,iBAAiB;;;;cC7B1B,iCAAU;cAMV,8BAAO;;;;;cAcP,kCAAW;;cAMX,kCAAW;cA6BX,kCAAW;;cAYX,oCAAa;;cAMb,sCAAe;cAKf,qCAAc;;;;;;;;;;;;cAoBd,iCAAU;cA6BV,mCAAY;cACZ,gCAAS;cACT,kCAAW;cAGX,gCAAS;cAGT,4BAAK;cACL,iCAAU;cACV,gCAAS;cACT,+BAAQ;cACR,mCAAY;cACZ,gCAAS;cACT,iCAAU;cACV,qCAAc;cACd,+BAAQ;cACR,2BAAI;cAGJ,6BAAM;cACN,gCAAS;cACT,8BAAO;cACP,gCAAO;cAGP,8BAAO;cACP,6BAAM;cACN,2BAAI;cACJ,4BAAK;cACL,gCAAS;cACT,6BAAM;cACN,8BAAO;cAGP,iCAAU;cACV,2BAAI;cACJ,0BAAG;cACH,8BAAO;cACP,2BAAI;cACJ,4BAAK;cACL,+BAAQ;cACR,4BAAK;cACL,+BAAQ;cACR,6BAAM;cAGN,gCAAS;cACT,gCAAS;cACT,+BAAQ;cACR,gCAAS;cACT,8BAAO;cACP,4BAAK;cACL,+BAAQ;cACR,8BAAO;cACP,mCAAY;cAGZ,2BAAI;cACJ,0BAAG;cACH,yBAAE;cACF,2BAAI;cAGJ,4BAAK;cACL,0BAAG;cACH,yBAAE;cACF,+BAAQ;cACR,6BAAM;cACN,6BAAM;cACN,4BAAK;cACL,2BAAI;cACJ,0BAAG;cACH,4BAAK;cACL,6BAAM;cAGN,yBAAE;cACF,+BAAQ;;cAWR,+BAAQ;;cAMR,4BAAK;;cAML,iCAAU;cAMV,0BAAG;cACH,4BAAK;cACL,4BAAK;cACL,4BAAK;cACL,6BAAM;cACN,6BAAM;cACN,+BAAQ;cACR,+BAAQ;cACR,yBAAE;cAGF,2BAAI;cAMJ,2BAAI;cACJ,6BAAM;cACN,6BAAM;cAIN,2BAAI;cACJ,4BAAK;cACL,2BAAI;cACJ,4BAAK;cACL,yBAAE;cACF,yBAAE;cACF,+BAAQ;cACR,yBAAE;cACF,gCAAS;cAMT,gCAAS;cA2HT,aAAW;;;UCxZP;EACf,QAAQ;EACR,QAAQ;;iBAGM,SAAS,iBAAiB;;;cCT7B,yBAAyB;WACpB;WACA,iBAAiB;EAE/B,YAAA,mBACA,iBAAiB,cACjB;;;;;;;;;;;;;;;iBA4BY,iBAAiB,gBAAgB"}