@abapify/adk 0.3.6 → 0.4.1

package/dist/factory-DtyrTGlN.mjs

@@ -0,0 +1,394 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region src/base/kinds.ts
+/**
+* ADK Object Kinds
+*
+* Central registry of all ADK object types.
+* Import specific kinds for type-safe usage:
+*
+* @example
+* import { TransportRequest } from '../base/kinds';
+* class AdkTransportRequest extends AdkObject<typeof TransportRequest> { ... }
+*/
+const TransportRequest = "TransportRequest";
+const TransportTask = "TransportTask";
+const Package = "Package";
+const Class = "Class";
+const Interface = "Interface";
+const FunctionGroup = "FunctionGroup";
+const FunctionModule = "FunctionModule";
+const Program = "Program";
+const Include = "Include";
+const Table = "Table";
+const Structure = "Structure";
+const DataElement = "DataElement";
+const Domain = "Domain";
+const TableType = "TableType";
+const MessageClass = "MessageClass";
+const EnhancementSpot = "EnhancementSpot";
+
+//#endregion
+//#region src/base/registry.ts
+/**
+* Parse ADT type into components
+*
+* @example
+* parseAdtType("DEVC/K") // { full: "DEVC/K", main: "DEVC", sub: "K" }
+* parseAdtType("DEVC")   // { full: "DEVC", main: "DEVC", sub: undefined }
+*/
+function parseAdtType(adtType) {
+	const [main, sub] = adtType.split("/");
+	return {
+		full: adtType,
+		main: main.toUpperCase(),
+		sub: sub?.toUpperCase()
+	};
+}
+/**
+* Get main type from ADT type
+*
+* @example
+* getMainType("DEVC/K") // "DEVC"
+* getMainType("CLAS")   // "CLAS"
+*/
+function getMainType(adtType) {
+	return parseAdtType(adtType).main;
+}
+/** Internal registry storage */
+const registry = /* @__PURE__ */ new Map();
+/** ADT main type to ADK kind mapping */
+const adtToKind = /* @__PURE__ */ new Map();
+/** ADK kind to ADT main type mapping (reverse) */
+const kindToAdt = /* @__PURE__ */ new Map();
+/**
+* Register an ADK object type
+*
+* @param adtType - ADT type, either main (e.g., "CLAS") or full (e.g., "TABL/DS")
+* @param kind - ADK kind constant
+* @param constructor - Object constructor
+* @param options - Optional endpoint and name transform settings
+*/
+function registerObjectType(adtType, kind, constructor, options) {
+	const normalizedType = adtType.toUpperCase();
+	registry.set(normalizedType, {
+		kind,
+		constructor,
+		endpoint: options?.endpoint,
+		nameTransform: options?.nameTransform,
+		normalizeName: options?.normalizeName
+	});
+	adtToKind.set(normalizedType, kind);
+	kindToAdt.set(kind, normalizedType);
+}
+/**
+* Resolve ADT type to registry entry
+*
+* Tries full type first (e.g., "TABL/DS"), then falls back to main type (e.g., "TABL").
+* This allows registering subtypes with different constructors/endpoints.
+*
+* @param adtType - Full or main ADT type (e.g., "DEVC/K" or "DEVC")
+* @returns Registry entry or undefined if not found
+*/
+function resolveType(adtType) {
+	const normalized = adtType.toUpperCase();
+	const fullMatch = registry.get(normalized);
+	if (fullMatch) return fullMatch;
+	const mainType = getMainType(adtType);
+	return registry.get(mainType);
+}
+/**
+* Resolve ADK kind to registry entry
+*
+* @param kind - ADK kind constant
+* @returns Registry entry or undefined if not found
+*/
+function resolveKind(kind) {
+	const adtType = kindToAdt.get(kind);
+	if (!adtType) return void 0;
+	return registry.get(adtType);
+}
+/**
+* Get ADK kind for ADT type
+*/
+function getKindForType(adtType) {
+	return adtToKind.get(getMainType(adtType));
+}
+/**
+* Get ADT main type for ADK kind
+*/
+function getTypeForKind(kind) {
+	return kindToAdt.get(kind);
+}
+/**
+* Check if ADT type is registered
+*/
+function isTypeRegistered(adtType) {
+	return registry.has(getMainType(adtType));
+}
+/**
+* Get all registered ADT types
+*/
+function getRegisteredTypes() {
+	return Array.from(registry.keys());
+}
+/**
+* Get all registered ADK kinds
+*/
+function getRegisteredKinds() {
+	return Array.from(kindToAdt.keys());
+}
+/**
+* Get ADT REST endpoint for a type (e.g., 'oo/classes', 'ddic/tabletypes')
+* Checks exact type first (e.g., 'TABL/DS') before falling back to main type.
+*/
+function getEndpointForType(adtType) {
+	return resolveType(adtType)?.endpoint;
+}
+/**
+* Build the full ADT object URI for a given type and name.
+*
+* @example
+* getObjectUri('CLAS', 'ZCL_MY_CLASS')  // '/sap/bc/adt/oo/classes/zcl_my_class'
+* getObjectUri('DEVC', 'ZPACKAGE')       // '/sap/bc/adt/packages/ZPACKAGE'
+* getObjectUri('TTYP', 'ZAGE_TTYP_STRTAB') // '/sap/bc/adt/ddic/tabletypes/zage_ttyp_strtab'
+*/
+function getObjectUri(adtType, name) {
+	const entry = resolveType(adtType);
+	if (!entry?.endpoint) return void 0;
+	const normalized = entry.normalizeName ? entry.normalizeName(name) : name;
+	const transformedName = entry.nameTransform === "preserve" ? encodeURIComponent(normalized) : encodeURIComponent(normalized.toLowerCase());
+	return `/sap/bc/adt/${entry.endpoint}/${transformedName}`;
+}
+/**
+* Normalize an object name using type-specific rules.
+*
+* If `adtType` is provided, applies that type's normalizer only.
+* Otherwise, collects all possible normalized forms from every registered type.
+*
+* @returns Array of candidate names (always includes the original).
+*
+* @example
+* normalizeObjectName('SAPLZAGE_FUGR')          // ['SAPLZAGE_FUGR', 'ZAGE_FUGR']
+* normalizeObjectName('SAPLZAGE_FUGR', 'FUGR')  // ['ZAGE_FUGR']
+* normalizeObjectName('ZCLAS_TEST')              // ['ZCLAS_TEST']  (no normalizer matches)
+*/
+function normalizeObjectName(name, adtType) {
+	if (adtType) return [resolveType(adtType)?.normalizeName?.(name) ?? name];
+	const candidates = new Set([name]);
+	for (const entry of registry.values()) if (entry.normalizeName) candidates.add(entry.normalizeName(name));
+	return Array.from(candidates);
+}
+/**
+* Extract the root object URI from a full (possibly sub-resource) URI.
+*
+* SAP locks must target the object root, not sub-resources like `/source/main`.
+* This function matches against registered endpoint prefixes and strips
+* everything after the object name segment.
+*
+* @returns The root object URI, or the original URI unchanged if no endpoint matches.
+*
+* @example
+* getObjectRootUri('/sap/bc/adt/functions/groups/zage_fugr/source/main')
+*   // → '/sap/bc/adt/functions/groups/zage_fugr'
+* getObjectRootUri('/sap/bc/adt/oo/classes/zcl_test/includes/testclasses')
+*   // → '/sap/bc/adt/oo/classes/zcl_test'
+* getObjectRootUri('/sap/bc/adt/oo/classes/zcl_test')
+*   // → '/sap/bc/adt/oo/classes/zcl_test'  (already root)
+*/
+function getObjectRootUri(uri) {
+	const ADT_PREFIX = "/sap/bc/adt/";
+	const endpoints = [];
+	for (const entry of registry.values()) if (entry.endpoint) endpoints.push(entry.endpoint);
+	endpoints.sort((a, b) => b.length - a.length);
+	for (const endpoint of endpoints) {
+		const prefix = `${ADT_PREFIX}${endpoint}/`;
+		if (uri.startsWith(prefix)) return `${prefix}${uri.slice(prefix.length).split("/")[0]}`;
+	}
+	return uri;
+}
+/**
+* Known ADT type to ADK kind mappings
+*
+* Repository Objects:
+* - DEVC → Package
+* - CLAS → Class
+* - INTF → Interface
+* - FUGR → FunctionGroup
+* - FUNC → FunctionModule
+* - PROG → Program
+* - INCL → Include
+*
+* Data Dictionary:
+* - TABL → Table
+* - STRU → Structure (actually TABL with different category)
+* - DTEL → DataElement
+* - DOMA → Domain
+* - TTYP → TableType
+*
+* Other:
+* - MSAG → MessageClass
+* - ENHS → EnhancementSpot
+*
+* CTS:
+* - (Transport requests/tasks use different identification)
+*/
+const ADT_TYPE_MAPPINGS = {
+	DEVC: Package,
+	CLAS: Class,
+	INTF: Interface,
+	FUGR: FunctionGroup,
+	FUNC: FunctionModule,
+	PROG: Program,
+	INCL: Include,
+	TABL: Table,
+	DTEL: DataElement,
+	DOMA: Domain,
+	TTYP: TableType,
+	MSAG: MessageClass,
+	ENHS: EnhancementSpot
+};
+
+//#endregion
+//#region src/factory.ts
+var factory_exports = /* @__PURE__ */ __exportAll({
+	AdkGenericObject: () => AdkGenericObject,
+	createAdk: () => createAdk,
+	createAdkFactory: () => createAdkFactory,
+	parseXmlIdentity: () => parseXmlIdentity
+});
+/** Pattern to extract adtcore:type from XML */
+const TYPE_PATTERN = /adtcore:type="([^"]+)"/;
+/** Pattern to extract adtcore:name from XML */
+const NAME_PATTERN = /adtcore:name="([^"]+)"/;
+/**
+* Extract ADT type and name from XML
+*
+* Relies on adtcore:type and adtcore:name attributes which are
+* the standard identifiers in ADT XML responses.
+*
+* @param xml - XML string from ADT response
+* @returns Extracted type and name, or undefined if not found
+*/
+function parseXmlIdentity(xml) {
+	const typeMatch = xml.match(TYPE_PATTERN);
+	const nameMatch = xml.match(NAME_PATTERN);
+	if (typeMatch && nameMatch) return {
+		type: typeMatch[1],
+		name: nameMatch[1]
+	};
+}
+/**
+* Generic ADK object for unregistered types
+*
+* Provides core functionality (adtcore attributes, links)
+* without type-specific features.
+*/
+var AdkGenericObject = class {
+	adtType;
+	adtMainType;
+	adtSubType;
+	ctx;
+	_name;
+	_data;
+	constructor(ctx, name, adtType) {
+		this.ctx = ctx;
+		this._name = name;
+		const parsed = parseAdtType(adtType);
+		this.adtType = parsed.full;
+		this.adtMainType = parsed.main;
+		this.adtSubType = parsed.sub;
+	}
+	get name() {
+		return this._name;
+	}
+	get type() {
+		return this.adtType;
+	}
+	/** Check if data is loaded */
+	get isLoaded() {
+		return this._data !== void 0;
+	}
+	/** Get raw data (if loaded) */
+	get data() {
+		return this._data;
+	}
+	/** Set data (for manual population) */
+	setData(data) {
+		this._data = data;
+	}
+};
+/**
+* Create ADK factory
+*
+* @param ctx - ADK context with services
+* @returns Factory instance
+*/
+function createAdkFactory(ctx) {
+	return {
+		ctx,
+		get(name, adtType) {
+			const entry = resolveType(adtType);
+			if (entry) return new entry.constructor(ctx, name);
+			return new AdkGenericObject(ctx, name, adtType);
+		},
+		getWithData(data, adtType) {
+			const entry = resolveType(adtType);
+			if (entry) return new entry.constructor(ctx, data);
+			const obj = new AdkGenericObject(ctx, data.name ?? "", adtType);
+			obj.setData(data);
+			return obj;
+		},
+		byKind(kind, name) {
+			const entry = resolveKind(kind);
+			if (!entry) throw new Error(`No constructor registered for kind: ${kind}`);
+			return new entry.constructor(ctx, name);
+		},
+		fromXml(xml) {
+			const identity = parseXmlIdentity(xml);
+			if (!identity) return;
+			return this.get(identity.name, identity.type);
+		},
+		create(adtType) {
+			return this.get("", adtType);
+		}
+	};
+}
+/**
+* Create ADK factory from ADT client
+*
+* Builds context from client and returns factory.
+* This is the main entry point for most users.
+*
+* @example
+* import { createAdtClient } from '@abapify/adt-client';
+* import { createAdk } from '@abapify/adk';
+*
+* const client = createAdtClient({ ... });
+* const adk = createAdk(client);
+*
+* const cls = adk.get('ZCL_TEST', 'CLAS');
+* await cls.load();
+*/
+function createAdk(client) {
+	return createAdkFactory({ client });
+}
+
+//#endregion
+export { Package as A, Domain as C, Include as D, FunctionModule as E, TransportRequest as F, TransportTask as I, Structure as M, Table as N, Interface as O, TableType as P, DataElement as S, FunctionGroup as T, parseAdtType as _, parseXmlIdentity as a, resolveType as b, getKindForType as c, getObjectUri as d, getRegisteredKinds as f, normalizeObjectName as g, isTypeRegistered as h, factory_exports as i, Program as j, MessageClass as k, getMainType as l, getTypeForKind as m, createAdk as n, ADT_TYPE_MAPPINGS as o, getRegisteredTypes as p, createAdkFactory as r, getEndpointForType as s, AdkGenericObject as t, getObjectRootUri as u, registerObjectType as v, EnhancementSpot as w, Class as x, resolveKind as y };
+//# sourceMappingURL=factory-DtyrTGlN.mjs.map

package/dist/factory-DtyrTGlN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory-DtyrTGlN.mjs","names":["kinds.Package","kinds.Class","kinds.Interface","kinds.FunctionGroup","kinds.FunctionModule","kinds.Program","kinds.Include","kinds.Table","kinds.DataElement","kinds.Domain","kinds.TableType","kinds.MessageClass","kinds.EnhancementSpot"],"sources":["../src/base/kinds.ts","../src/base/registry.ts","../src/factory.ts"],"sourcesContent":["/**\n * ADK Object Kinds\n *\n * Central registry of all ADK object types.\n * Import specific kinds for type-safe usage:\n *\n * @example\n * import { TransportRequest } from '../base/kinds';\n * class AdkTransportRequest extends AdkObject<typeof TransportRequest> { ... }\n */\n\n// CTS\nexport const TransportRequest = 'TransportRequest' as const;\nexport const TransportTask = 'TransportTask' as const;\n\n// Repository Objects\nexport const Package = 'Package' as const;\nexport const Class = 'Class' as const;\nexport const Interface = 'Interface' as const;\nexport const FunctionGroup = 'FunctionGroup' as const;\nexport const FunctionModule = 'FunctionModule' as const;\nexport const Program = 'Program' as const;\nexport const Include = 'Include' as const;\n\n// Data Dictionary\nexport const Table = 'Table' as const;\nexport const Structure = 'Structure' as const;\nexport const DataElement = 'DataElement' as const;\nexport const Domain = 'Domain' as const;\nexport const TableType = 'TableType' as const;\n\n// Other\nexport const MessageClass = 'MessageClass' as const;\nexport const EnhancementSpot = 'EnhancementSpot' as const;\n\n/** Union type of all ADK kinds */\nexport type AdkKind =\n  | typeof TransportRequest\n  | typeof TransportTask\n  | typeof Package\n  | typeof Class\n  | typeof Interface\n  | typeof FunctionGroup\n  | typeof FunctionModule\n  | typeof Program\n  | typeof Include\n  | typeof Table\n  | typeof Structure\n  | typeof DataElement\n  | typeof Domain\n  | typeof TableType\n  | typeof MessageClass\n  | typeof EnhancementSpot;\n\n// ============================================\n// Type-safe Kind → Object mapping\n// ============================================\n\n// Import concrete types for mapping (type-only to avoid circular deps)\nimport type { AdkClass } from '../objects/repository/clas/clas.model';\nimport type { AdkInterface } from '../objects/repository/intf/intf.model';\nimport type { AdkPackage } from '../objects/repository/devc/devc.model';\nimport type { AdkProgram } from '../objects/repository/prog/prog.model';\nimport type { AdkInclude } from '../objects/repository/incl/incl.model';\nimport type { AdkFunctionGroup } from '../objects/repository/fugr/fugr.model';\nimport type { AdkFunctionModule } from '../objects/repository/fugr/func/func.model';\nimport type {\n  AdkTransportRequest,\n  AdkTransportTask,\n} from '../objects/cts/transport/transport';\nimport type { AdkObject } from './model';\nimport type { AdkDomain } from '../objects/ddic/doma/doma.model';\nimport type { AdkDataElement } from '../objects/ddic/dtel/dtel.model';\nimport type { AdkTable, AdkStructure } from '../objects/ddic/tabl/tabl.model';\nimport type { AdkTableType } from '../objects/ddic/ttyp/ttyp.model';\n\n/**\n * Maps ADK kind to concrete object type\n *\n * Enables type-safe factory methods:\n * ```ts\n * const cls = factory.byKind(Class, 'ZCL_TEST');  // → AdkClass\n * const intf = factory.byKind(Interface, 'ZIF'); // → AdkInterface\n * ```\n */\nexport type AdkObjectForKind<K extends AdkKind> = K extends typeof Class\n  ? AdkClass\n  : K extends typeof Interface\n    ? AdkInterface\n    : K extends typeof Package\n      ? AdkPackage\n      : K extends typeof Program\n        ? AdkProgram\n        : K extends typeof Include\n          ? AdkInclude\n          : K extends typeof FunctionGroup\n            ? AdkFunctionGroup\n            : K extends typeof FunctionModule\n              ? AdkFunctionModule\n              : K extends typeof TransportRequest\n                ? AdkTransportRequest\n                : K extends typeof TransportTask\n                  ? AdkTransportTask\n                  : K extends typeof Domain\n                    ? AdkDomain\n                    : K extends typeof DataElement\n                      ? AdkDataElement\n                      : K extends typeof Table\n                        ? AdkTable\n                        : K extends typeof Structure\n                          ? AdkStructure\n                          : K extends typeof TableType\n                            ? AdkTableType\n                            : AdkObject; // fallback\n","/**\n * ADK Object Registry\n *\n * Maps ADT types to ADK object constructors.\n * Supports both full types (DEVC/K) and main types (DEVC).\n *\n * Architecture:\n * - ADT type (external): \"DEVC/K\", \"CLAS/OC\" - from SAP\n * - ADK kind (internal): Package, Class - our abstraction\n * - Constructor: AdkPackage, AdkClass - implementation\n */\n\nimport type { AdkContext } from './context';\nimport type { AdkObject } from './model';\nimport type { AdkKind } from './kinds';\nimport * as kinds from './kinds';\n\n// ============================================\n// Types\n// ============================================\n\n/** Constructor signature for ADK objects */\n\nexport type AdkObjectConstructor<\n  T extends AdkObject<AdkKind, any> = AdkObject<AdkKind, any>,\n> = new (ctx: AdkContext, nameOrData: string | any) => T;\n\n/** How to transform object name for the URI path segment */\nexport type NameTransform = 'lowercase' | 'preserve';\n\n/** Registry entry with constructor and kind */\nexport interface RegistryEntry {\n  readonly kind: AdkKind;\n  readonly constructor: AdkObjectConstructor;\n  /** ADT REST endpoint path segment (e.g., 'oo/classes', 'ddic/tabletypes') */\n  readonly endpoint?: string;\n  /** How to transform the object name in URIs (default: lowercase) */\n  readonly nameTransform?: NameTransform;\n  /** Optional name normalizer — e.g., strip SAPL prefix for FUGR */\n  readonly normalizeName?: (name: string) => string;\n}\n\n// ============================================\n// ADT Type Utilities\n// ============================================\n\n/**\n * Parse ADT type into components\n *\n * @example\n * parseAdtType(\"DEVC/K\") // { full: \"DEVC/K\", main: \"DEVC\", sub: \"K\" }\n * parseAdtType(\"DEVC\")   // { full: \"DEVC\", main: \"DEVC\", sub: undefined }\n */\nexport function parseAdtType(adtType: string): {\n  full: string;\n  main: string;\n  sub?: string;\n} {\n  const [main, sub] = adtType.split('/');\n  return {\n    full: adtType,\n    main: main.toUpperCase(),\n    sub: sub?.toUpperCase(),\n  };\n}\n\n/**\n * Get main type from ADT type\n *\n * @example\n * getMainType(\"DEVC/K\") // \"DEVC\"\n * getMainType(\"CLAS\")   // \"CLAS\"\n */\nexport function getMainType(adtType: string): string {\n  return parseAdtType(adtType).main;\n}\n\n// ============================================\n// Registry\n// ============================================\n\n/** Internal registry storage */\nconst registry = new Map<string, RegistryEntry>();\n\n/** ADT main type to ADK kind mapping */\nconst adtToKind = new Map<string, AdkKind>();\n\n/** ADK kind to ADT main type mapping (reverse) */\nconst kindToAdt = new Map<AdkKind, string>();\n\n/**\n * Test-only: clear all registry state.\n *\n * The registry is module-level singleton state populated by side-effectful\n * `registerObjectType()` calls in `src/objects/repository/**`. Tests that\n * exercise registration need a clean slate, but production code must never\n * call this — it would break every ADK object type resolution.\n *\n * Name intentionally uses the `__` prefix to signal \"not part of the public\n * API\". Do not import this from runtime code.\n */\nexport function __resetRegistryForTests(): void {\n  registry.clear();\n  adtToKind.clear();\n  kindToAdt.clear();\n}\n\n/** Options for registerObjectType */\nexport interface RegisterObjectTypeOptions {\n  /** ADT REST endpoint path segment (e.g., 'oo/classes', 'ddic/tabletypes') */\n  endpoint?: string;\n  /** How to transform the object name in URIs (default: 'lowercase') */\n  nameTransform?: NameTransform;\n  /** Optional name normalizer — e.g., strip SAPL prefix for FUGR */\n  normalizeName?: (name: string) => string;\n}\n\n/**\n * Register an ADK object type\n *\n * @param adtType - ADT type, either main (e.g., \"CLAS\") or full (e.g., \"TABL/DS\")\n * @param kind - ADK kind constant\n * @param constructor - Object constructor\n * @param options - Optional endpoint and name transform settings\n */\nexport function registerObjectType(\n  adtType: string,\n  kind: AdkKind,\n  constructor: AdkObjectConstructor,\n  options?: RegisterObjectTypeOptions,\n): void {\n  const normalizedType = adtType.toUpperCase();\n\n  registry.set(normalizedType, {\n    kind,\n    constructor,\n    endpoint: options?.endpoint,\n    nameTransform: options?.nameTransform,\n    normalizeName: options?.normalizeName,\n  });\n  adtToKind.set(normalizedType, kind);\n  kindToAdt.set(kind, normalizedType);\n}\n\n/**\n * Resolve ADT type to registry entry\n *\n * Tries full type first (e.g., \"TABL/DS\"), then falls back to main type (e.g., \"TABL\").\n * This allows registering subtypes with different constructors/endpoints.\n *\n * @param adtType - Full or main ADT type (e.g., \"DEVC/K\" or \"DEVC\")\n * @returns Registry entry or undefined if not found\n */\nexport function resolveType(adtType: string): RegistryEntry | undefined {\n  const normalized = adtType.toUpperCase();\n  // Try full type first (e.g., \"TABL/DS\")\n  const fullMatch = registry.get(normalized);\n  if (fullMatch) return fullMatch;\n  // Fall back to main type (e.g., \"TABL\")\n  const mainType = getMainType(adtType);\n  return registry.get(mainType);\n}\n\n/**\n * Resolve ADK kind to registry entry\n *\n * @param kind - ADK kind constant\n * @returns Registry entry or undefined if not found\n */\nexport function resolveKind(kind: AdkKind): RegistryEntry | undefined {\n  const adtType = kindToAdt.get(kind);\n  if (!adtType) return undefined;\n  return registry.get(adtType);\n}\n\n/**\n * Get ADK kind for ADT type\n */\nexport function getKindForType(adtType: string): AdkKind | undefined {\n  return adtToKind.get(getMainType(adtType));\n}\n\n/**\n * Get ADT main type for ADK kind\n */\nexport function getTypeForKind(kind: AdkKind): string | undefined {\n  return kindToAdt.get(kind);\n}\n\n/**\n * Check if ADT type is registered\n */\nexport function isTypeRegistered(adtType: string): boolean {\n  return registry.has(getMainType(adtType));\n}\n\n/**\n * Get all registered ADT types\n */\nexport function getRegisteredTypes(): string[] {\n  return Array.from(registry.keys());\n}\n\n/**\n * Get all registered ADK kinds\n */\nexport function getRegisteredKinds(): AdkKind[] {\n  return Array.from(kindToAdt.keys());\n}\n\n/**\n * Get ADT REST endpoint for a type (e.g., 'oo/classes', 'ddic/tabletypes')\n * Checks exact type first (e.g., 'TABL/DS') before falling back to main type.\n */\nexport function getEndpointForType(adtType: string): string | undefined {\n  return resolveType(adtType)?.endpoint;\n}\n\n/**\n * Build the full ADT object URI for a given type and name.\n *\n * @example\n * getObjectUri('CLAS', 'ZCL_MY_CLASS')  // '/sap/bc/adt/oo/classes/zcl_my_class'\n * getObjectUri('DEVC', 'ZPACKAGE')       // '/sap/bc/adt/packages/ZPACKAGE'\n * getObjectUri('TTYP', 'ZAGE_TTYP_STRTAB') // '/sap/bc/adt/ddic/tabletypes/zage_ttyp_strtab'\n */\nexport function getObjectUri(\n  adtType: string,\n  name: string,\n): string | undefined {\n  const entry = resolveType(adtType);\n  if (!entry?.endpoint) return undefined;\n\n  const normalized = entry.normalizeName ? entry.normalizeName(name) : name;\n  const transformedName =\n    entry.nameTransform === 'preserve'\n      ? encodeURIComponent(normalized)\n      : encodeURIComponent(normalized.toLowerCase());\n\n  return `/sap/bc/adt/${entry.endpoint}/${transformedName}`;\n}\n\n/**\n * Normalize an object name using type-specific rules.\n *\n * If `adtType` is provided, applies that type's normalizer only.\n * Otherwise, collects all possible normalized forms from every registered type.\n *\n * @returns Array of candidate names (always includes the original).\n *\n * @example\n * normalizeObjectName('SAPLZAGE_FUGR')          // ['SAPLZAGE_FUGR', 'ZAGE_FUGR']\n * normalizeObjectName('SAPLZAGE_FUGR', 'FUGR')  // ['ZAGE_FUGR']\n * normalizeObjectName('ZCLAS_TEST')              // ['ZCLAS_TEST']  (no normalizer matches)\n */\nexport function normalizeObjectName(name: string, adtType?: string): string[] {\n  if (adtType) {\n    const entry = resolveType(adtType);\n    const normalized = entry?.normalizeName?.(name) ?? name;\n    return [normalized];\n  }\n\n  // No type hint — collect all distinct candidates from every registered normalizer\n  const candidates = new Set<string>([name]);\n  for (const entry of registry.values()) {\n    if (entry.normalizeName) {\n      candidates.add(entry.normalizeName(name));\n    }\n  }\n  return Array.from(candidates);\n}\n\n/**\n * Extract the root object URI from a full (possibly sub-resource) URI.\n *\n * SAP locks must target the object root, not sub-resources like `/source/main`.\n * This function matches against registered endpoint prefixes and strips\n * everything after the object name segment.\n *\n * @returns The root object URI, or the original URI unchanged if no endpoint matches.\n *\n * @example\n * getObjectRootUri('/sap/bc/adt/functions/groups/zage_fugr/source/main')\n *   // → '/sap/bc/adt/functions/groups/zage_fugr'\n * getObjectRootUri('/sap/bc/adt/oo/classes/zcl_test/includes/testclasses')\n *   // → '/sap/bc/adt/oo/classes/zcl_test'\n * getObjectRootUri('/sap/bc/adt/oo/classes/zcl_test')\n *   // → '/sap/bc/adt/oo/classes/zcl_test'  (already root)\n */\nexport function getObjectRootUri(uri: string): string {\n  const ADT_PREFIX = '/sap/bc/adt/';\n\n  // Collect all registered endpoints, sorted longest-first to avoid partial matches\n  const endpoints: string[] = [];\n  for (const entry of registry.values()) {\n    if (entry.endpoint) endpoints.push(entry.endpoint);\n  }\n  endpoints.sort((a, b) => b.length - a.length);\n\n  for (const endpoint of endpoints) {\n    const prefix = `${ADT_PREFIX}${endpoint}/`;\n    if (uri.startsWith(prefix)) {\n      // Next segment after the endpoint prefix is the object name\n      const rest = uri.slice(prefix.length);\n      const objectName = rest.split('/')[0];\n      return `${prefix}${objectName}`;\n    }\n  }\n\n  return uri;\n}\n\n// ============================================\n// Built-in Registrations\n// ============================================\n\n// These will be populated by object modules when they're imported\n// Each object module calls registerObjectType() in its module scope\n\n// Example (done in clas.model.ts):\n// registerObjectType('CLAS', kinds.Class, AdkClass);\n\n// For now, we export the registration function and let objects self-register\n// This avoids circular dependencies\n\n// ============================================\n// Type Mappings (for reference/documentation)\n// ============================================\n\n/**\n * Known ADT type to ADK kind mappings\n *\n * Repository Objects:\n * - DEVC → Package\n * - CLAS → Class\n * - INTF → Interface\n * - FUGR → FunctionGroup\n * - FUNC → FunctionModule\n * - PROG → Program\n * - INCL → Include\n *\n * Data Dictionary:\n * - TABL → Table\n * - STRU → Structure (actually TABL with different category)\n * - DTEL → DataElement\n * - DOMA → Domain\n * - TTYP → TableType\n *\n * Other:\n * - MSAG → MessageClass\n * - ENHS → EnhancementSpot\n *\n * CTS:\n * - (Transport requests/tasks use different identification)\n */\nexport const ADT_TYPE_MAPPINGS = {\n  // Repository\n  DEVC: kinds.Package,\n  CLAS: kinds.Class,\n  INTF: kinds.Interface,\n  FUGR: kinds.FunctionGroup,\n  FUNC: kinds.FunctionModule,\n  PROG: kinds.Program,\n  INCL: kinds.Include,\n\n  // Data Dictionary\n  TABL: kinds.Table,\n  DTEL: kinds.DataElement,\n  DOMA: kinds.Domain,\n  TTYP: kinds.TableType,\n\n  // Other\n  MSAG: kinds.MessageClass,\n  ENHS: kinds.EnhancementSpot,\n} as const;\n","/**\n * ADK v2 - Generic Factory\n *\n * Single entry point for creating ADK objects.\n * Resolves ADT types to correct ADK object implementations.\n *\n * Resolution methods:\n * - get(name, adtType) - By name and ADT type (unique identifier)\n * - byKind(kind, name) - By ADK kind (type-safe)\n * - fromXml(xml) - Parse from XML response\n * - create(adtType) - Create new object (deferred)\n */\n\nimport type { AdkContext } from './base/context';\nimport type { AdkObject } from './base/model';\nimport type { AdkKind, AdkObjectForKind } from './base/kinds';\nimport { resolveType, resolveKind, parseAdtType } from './base/registry';\n\n// ============================================\n// XML Parsing Utilities\n// ============================================\n\n/** Pattern to extract adtcore:type from XML */\nconst TYPE_PATTERN = /adtcore:type=\"([^\"]+)\"/;\n\n/** Pattern to extract adtcore:name from XML */\nconst NAME_PATTERN = /adtcore:name=\"([^\"]+)\"/;\n\n/**\n * Extract ADT type and name from XML\n *\n * Relies on adtcore:type and adtcore:name attributes which are\n * the standard identifiers in ADT XML responses.\n *\n * @param xml - XML string from ADT response\n * @returns Extracted type and name, or undefined if not found\n */\nexport function parseXmlIdentity(\n  xml: string,\n): { type: string; name: string } | undefined {\n  const typeMatch = xml.match(TYPE_PATTERN);\n  const nameMatch = xml.match(NAME_PATTERN);\n\n  if (typeMatch && nameMatch) {\n    return {\n      type: typeMatch[1],\n      name: nameMatch[1],\n    };\n  }\n\n  return undefined;\n}\n\n// ============================================\n// Generic Object (Fallback)\n// ============================================\n\n/**\n * Generic ADK object for unregistered types\n *\n * Provides core functionality (adtcore attributes, links)\n * without type-specific features.\n */\nexport class AdkGenericObject {\n  readonly adtType: string;\n  readonly adtMainType: string;\n  readonly adtSubType?: string;\n\n  protected readonly ctx: AdkContext;\n  protected _name: string;\n  protected _data?: unknown;\n\n  constructor(ctx: AdkContext, name: string, adtType: string) {\n    this.ctx = ctx;\n    this._name = name;\n\n    const parsed = parseAdtType(adtType);\n    this.adtType = parsed.full;\n    this.adtMainType = parsed.main;\n    this.adtSubType = parsed.sub;\n  }\n\n  get name(): string {\n    return this._name;\n  }\n  get type(): string {\n    return this.adtType;\n  }\n\n  /** Check if data is loaded */\n  get isLoaded(): boolean {\n    return this._data !== undefined;\n  }\n\n  /** Get raw data (if loaded) */\n  get data(): unknown {\n    return this._data;\n  }\n\n  /** Set data (for manual population) */\n  setData(data: unknown): void {\n    this._data = data;\n  }\n}\n\n// ============================================\n// Factory Interface\n// ============================================\n\n/**\n * ADK Factory - Generic object creation\n */\nexport interface AdkFactory {\n  /** Context used by this factory */\n  readonly ctx: AdkContext;\n\n  /**\n   * Get object by name and ADT type\n   *\n   * Supports both full types (DEVC/K) and main types (DEVC).\n   * Returns deferred object - call load() to fetch data.\n   *\n   * @example\n   * const pkg = factory.get('ZPACKAGE', 'DEVC/K');\n   * await pkg.load();\n   *\n   * const cls = factory.get('ZCL_TEST', 'CLAS');\n   * await cls.load();\n   */\n  get(name: string, adtType: string): AdkObject | AdkGenericObject;\n\n  /**\n   * Get object with initial data (for deserialization)\n   *\n   * Creates object pre-populated with data - no load() needed.\n   * Used when deserializing from files rather than loading from SAP.\n   *\n   * @example\n   * const cls = factory.getWithData({ name: 'ZCL_TEST', description: 'Test' }, 'CLAS');\n   * // cls.isLoaded is true, no need to call load()\n   */\n  getWithData(\n    data: Record<string, unknown>,\n    adtType: string,\n  ): AdkObject | AdkGenericObject;\n\n  /**\n   * Get object by ADK kind (type-safe)\n   *\n   * Returns correctly typed object based on kind.\n   * TypeScript infers the concrete return type from the kind parameter.\n   *\n   * @example\n   * import { Class, Interface } from '@abapify/adk';\n   * const cls = factory.byKind(Class, 'ZCL_TEST');     // → AdkClass\n   * const intf = factory.byKind(Interface, 'ZIF_TEST'); // → AdkInterface\n   */\n  byKind<K extends AdkKind>(kind: K, name: string): AdkObjectForKind<K>;\n\n  /**\n   * Create object from XML response\n   *\n   * Parses XML to extract type and name, then constructs\n   * the correct object type.\n   *\n   * @example\n   * const xml = await client.fetch('/sap/bc/adt/oo/classes/ZCL_TEST');\n   * const cls = factory.fromXml(xml);\n   */\n  fromXml(xml: string): AdkObject | AdkGenericObject | undefined;\n\n  /**\n   * Create new object (for creation workflows)\n   *\n   * Returns deferred object without name - used when\n   * creating new objects in SAP.\n   */\n  create(adtType: string): AdkObject | AdkGenericObject;\n}\n\n// ============================================\n// Factory Implementation\n// ============================================\n\n/**\n * Create ADK factory\n *\n * @param ctx - ADK context with services\n * @returns Factory instance\n */\nexport function createAdkFactory(ctx: AdkContext): AdkFactory {\n  return {\n    ctx,\n\n    get(name: string, adtType: string): AdkObject | AdkGenericObject {\n      const entry = resolveType(adtType);\n\n      if (entry) {\n        return new entry.constructor(ctx, name);\n      }\n\n      // Fallback to generic object\n      return new AdkGenericObject(ctx, name, adtType);\n    },\n\n    getWithData(\n      data: Record<string, unknown>,\n      adtType: string,\n    ): AdkObject | AdkGenericObject {\n      const entry = resolveType(adtType);\n\n      if (entry) {\n        // Pass data directly to constructor - it will extract name from data.name\n        return new entry.constructor(ctx, data);\n      }\n\n      // Fallback to generic object with name from data\n      const obj = new AdkGenericObject(\n        ctx,\n        (data as { name?: string }).name ?? '',\n        adtType,\n      );\n      obj.setData(data);\n      return obj;\n    },\n\n    byKind<K extends AdkKind>(kind: K, name: string): AdkObjectForKind<K> {\n      const entry = resolveKind(kind);\n\n      if (!entry) {\n        throw new Error(`No constructor registered for kind: ${kind}`);\n      }\n\n      // Type assertion: registry guarantees correct constructor for kind\n      return new entry.constructor(ctx, name) as AdkObjectForKind<K>;\n    },\n\n    fromXml(xml: string): AdkObject | AdkGenericObject | undefined {\n      const identity = parseXmlIdentity(xml);\n\n      if (!identity) {\n        return undefined;\n      }\n\n      return this.get(identity.name, identity.type);\n    },\n\n    create(adtType: string): AdkObject | AdkGenericObject {\n      // Create with empty name - will be set during creation workflow\n      return this.get('', adtType);\n    },\n  };\n}\n\n// ============================================\n// Convenience: Create factory from ADT client\n// ============================================\n\n// Factory is the boundary - imports AdtClient directly from adt-client\nimport type { AdtClient } from '@abapify/adt-client';\n\n/**\n * Create ADK factory from ADT client\n *\n * Builds context from client and returns factory.\n * This is the main entry point for most users.\n *\n * @example\n * import { createAdtClient } from '@abapify/adt-client';\n * import { createAdk } from '@abapify/adk';\n *\n * const client = createAdtClient({ ... });\n * const adk = createAdk(client);\n *\n * const cls = adk.get('ZCL_TEST', 'CLAS');\n * await cls.load();\n */\nexport function createAdk(client: AdtClient): AdkFactory {\n  // Build context with client reference\n  // Objects access client via ctx.client\n  const ctx: AdkContext = {\n    client,\n  };\n\n  return createAdkFactory(ctx);\n}\n"],"mappings":"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"}