@canon-protocol/sdk 8.0.0

package/dist/repositories/PublisherIndex.js

@@ -0,0 +1,127 @@
+import { VersionOperator } from '@canon-protocol/types/document/models/enums';
+import { PublisherConfigResolver } from './PublisherConfig.js';
+export class PublisherIndex {
+    indexCache = new Map();
+    configResolver;
+    constructor(configResolver) {
+        this.configResolver = configResolver ?? new PublisherConfigResolver();
+    }
+    async resolveVersion(publisher, import_) {
+        const packageVersions = await this.getPackageVersions(publisher, import_.packageName);
+        if (packageVersions.length === 0) {
+            return null;
+        }
+        const compatible = packageVersions.filter(v => this.isVersionCompatible(v, import_.version, import_.versionOperator));
+        if (compatible.length === 0) {
+            return null;
+        }
+        compatible.sort((a, b) => this.compareVersionStrings(b, a));
+        return compatible[0];
+    }
+    async getHighestVersion(publisher, packageName) {
+        const versions = await this.getPackageVersions(publisher, packageName);
+        if (versions.length === 0)
+            return null;
+        const sorted = [...versions].sort((a, b) => this.compareVersionStrings(b, a));
+        return sorted[0];
+    }
+    async getPackageUrl(publisher, packageName, version) {
+        const config = await this.configResolver.getConfig(publisher);
+        return this.configResolver.resolvePackageUrl(publisher, packageName, version, config);
+    }
+    async getPackageVersions(publisher, packageName) {
+        let index = this.indexCache.get(publisher);
+        if (!index) {
+            index = await this.fetchIndex(publisher);
+            this.indexCache.set(publisher, index);
+        }
+        return index.get(packageName) ?? [];
+    }
+    async fetchIndex(publisher) {
+        const config = await this.configResolver.getConfig(publisher);
+        const url = this.configResolver.resolveIndexUrl(publisher, config);
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch publisher index: ${url} (${response.status} ${response.statusText})`);
+        }
+        const text = await response.text();
+        return PublisherIndex.parseIndex(text);
+    }
+    static parseIndex(text) {
+        const index = new Map();
+        for (const line of text.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const slashIndex = trimmed.indexOf('/');
+            if (slashIndex === -1)
+                continue;
+            const pkg = trimmed.substring(0, slashIndex);
+            const version = trimmed.substring(slashIndex + 1);
+            if (!pkg || !version)
+                continue;
+            const versions = index.get(pkg);
+            if (versions) {
+                versions.push(version);
+            }
+            else {
+                index.set(pkg, [version]);
+            }
+        }
+        return index;
+    }
+    isVersionCompatible(candidateStr, requiredVersion, operator) {
+        const candidate = PublisherIndex.parseVersion(candidateStr);
+        if (!candidate)
+            return false;
+        switch (operator) {
+            case VersionOperator.Any:
+                return true;
+            case VersionOperator.Exact:
+                return (candidate.major === requiredVersion.major &&
+                    candidate.minor === requiredVersion.minor &&
+                    candidate.patch === requiredVersion.patch);
+            case VersionOperator.Compatible:
+                return (candidate.major === requiredVersion.major &&
+                    candidate.minor === requiredVersion.minor &&
+                    candidate.patch >= requiredVersion.patch);
+            case VersionOperator.Major:
+                if (candidate.major !== requiredVersion.major)
+                    return false;
+                if (candidate.minor > requiredVersion.minor)
+                    return true;
+                if (candidate.minor === requiredVersion.minor) {
+                    return candidate.patch >= requiredVersion.patch;
+                }
+                return false;
+            default:
+                return false;
+        }
+    }
+    static parseVersion(str) {
+        const parts = str.split('.');
+        if (parts.length < 2)
+            return null;
+        const major = parseInt(parts[0], 10);
+        const minor = parseInt(parts[1], 10);
+        const patch = parts.length >= 3 ? parseInt(parts[2], 10) : 0;
+        if (isNaN(major) || isNaN(minor) || isNaN(patch))
+            return null;
+        return { major, minor, patch };
+    }
+    compareVersionStrings(a, b) {
+        const va = PublisherIndex.parseVersion(a);
+        const vb = PublisherIndex.parseVersion(b);
+        if (!va && !vb)
+            return 0;
+        if (!va)
+            return -1;
+        if (!vb)
+            return 1;
+        if (va.major !== vb.major)
+            return va.major - vb.major;
+        if (va.minor !== vb.minor)
+            return va.minor - vb.minor;
+        return va.patch - vb.patch;
+    }
+}

package/dist/repositories/RepositoryFactory.d.ts

@@ -0,0 +1,6 @@
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { ICanonParser } from '@canon-protocol/types/document/parsing';
+export declare class RepositoryFactory {
+    static createComposite(cachePath?: string, workspacePath?: string, parser?: ICanonParser): ICanonDocumentRepository;
+    static createFromEnvironment(parser?: ICanonParser): ICanonDocumentRepository;
+}

package/dist/repositories/RepositoryFactory.js

@@ -0,0 +1,13 @@
+import { CompositeCanonDocumentRepository } from './CompositeCanonDocumentRepository.js';
+export class RepositoryFactory {
+    static createComposite(cachePath, workspacePath, parser) {
+        const cache = cachePath ?? '.canon';
+        const workspace = workspacePath ?? '.';
+        return new CompositeCanonDocumentRepository(cache, workspace, parser);
+    }
+    static createFromEnvironment(parser) {
+        const cachePath = process.env.CANON_PACKAGE_CACHE ?? '.canon';
+        const workspacePath = process.env.CANON_WORKSPACE_PATH ?? '.';
+        return RepositoryFactory.createComposite(cachePath, workspacePath, parser);
+    }
+}

package/dist/repositories/index.d.ts

@@ -0,0 +1,9 @@
+export { InMemoryCanonDocumentRepository } from './InMemoryCanonDocumentRepository.js';
+export { FileSystemCanonDocumentRepository } from './FileSystemCanonDocumentRepository.js';
+export { CompositeCanonDocumentRepository, DocumentLocation } from './CompositeCanonDocumentRepository.js';
+export { RepositoryFactory } from './RepositoryFactory.js';
+export { HttpCanonDocumentRepository } from './HttpCanonDocumentRepository.js';
+export { PublisherIndex } from './PublisherIndex.js';
+export { PublisherConfigResolver } from './PublisherConfig.js';
+export type { PublisherConfig } from './PublisherConfig.js';
+export type { ICanonDocumentRepository, CanonDocument, DocumentReference } from '@canon-protocol/types/document/models';

package/dist/repositories/index.js

@@ -0,0 +1,7 @@
+export { InMemoryCanonDocumentRepository } from './InMemoryCanonDocumentRepository.js';
+export { FileSystemCanonDocumentRepository } from './FileSystemCanonDocumentRepository.js';
+export { CompositeCanonDocumentRepository, DocumentLocation } from './CompositeCanonDocumentRepository.js';
+export { RepositoryFactory } from './RepositoryFactory.js';
+export { HttpCanonDocumentRepository } from './HttpCanonDocumentRepository.js';
+export { PublisherIndex } from './PublisherIndex.js';
+export { PublisherConfigResolver } from './PublisherConfig.js';

package/dist/resolution/CanonUri.d.ts

@@ -0,0 +1,10 @@
+import type { Version } from '@canon-protocol/types/document/models/types';
+export declare class CanonUri {
+    publisher: string;
+    package_: string;
+    name: string;
+    version: Version;
+    constructor(publisher: string, package_: string, name: string, version: Version);
+    static parse(canonString: string): CanonUri;
+    toString(): string;
+}

package/dist/resolution/CanonUri.js

@@ -0,0 +1,55 @@
+export class CanonUri {
+    publisher;
+    package_;
+    name;
+    version;
+    constructor(publisher, package_, name, version) {
+        this.publisher = publisher;
+        this.package_ = package_;
+        this.name = name;
+        this.version = version;
+    }
+    static parse(canonString) {
+        if (!canonString || canonString.trim().length === 0) {
+            throw new Error('Canon URI string cannot be null or empty');
+        }
+        const parts = canonString.split('@');
+        if (parts.length !== 2) {
+            throw new Error(`Invalid canon URI format: ${canonString}. Expected format: publisher/package/name@version`);
+        }
+        const pathPart = parts[0];
+        const versionPart = parts[1];
+        const segments = pathPart.split('/');
+        if (segments.length !== 3) {
+            throw new Error(`Invalid canon URI path format: ${pathPart}. Expected format: publisher/package/name`);
+        }
+        const versionParts = versionPart.split('.').map(Number);
+        const version = {
+            major: versionParts[0] || 0,
+            minor: versionParts[1] || 0,
+            patch: versionParts[2] || 0,
+            toString: () => `${versionParts[0] || 0}.${versionParts[1] || 0}.${versionParts[2] || 0}`,
+            equals: (obj) => {
+                if (!obj || typeof obj !== 'object')
+                    return false;
+                return obj.major === (versionParts[0] || 0) &&
+                    obj.minor === (versionParts[1] || 0) &&
+                    obj.patch === (versionParts[2] || 0);
+            },
+            getHashCode: () => {
+                return ((versionParts[0] || 0) << 20) | ((versionParts[1] || 0) << 10) | (versionParts[2] || 0);
+            },
+            compareTo: (other) => {
+                if ((versionParts[0] || 0) !== other.major)
+                    return (versionParts[0] || 0) - other.major;
+                if ((versionParts[1] || 0) !== other.minor)
+                    return (versionParts[1] || 0) - other.minor;
+                return (versionParts[2] || 0) - other.patch;
+            }
+        };
+        return new CanonUri(segments[0], segments[1], segments[2], version);
+    }
+    toString() {
+        return `${this.publisher}/${this.package_}/${this.name}@${this.version.major}.${this.version.minor}.${this.version.patch}`;
+    }
+}

package/dist/resolution/CanonUriBuilder.d.ts

@@ -0,0 +1,12 @@
+import type { CanonDocument, Version } from '@canon-protocol/types/document/models/types';
+import type { ResourceResolver } from './ResourceResolver.js';
+import type { ResourceResolutionResult } from './ResourceResolutionResult.js';
+import { CanonUri } from './CanonUri.js';
+export declare class CanonUriBuilder {
+    private readonly resourceResolver;
+    constructor(resourceResolver: ResourceResolver);
+    buildFromNameAsync(entityName: string, currentDocument: CanonDocument): Promise<CanonUri | null>;
+    buildFromName(entityName: string, entityIndex: Map<string, ResourceResolutionResult>, currentDocument: CanonDocument): CanonUri | null;
+    create(publisher: string, package_: string, name: string, version: Version): CanonUri;
+    private findPackageNameForAlias;
+}

package/dist/resolution/CanonUriBuilder.js

@@ -0,0 +1,51 @@
+import { CanonUri } from './CanonUri.js';
+export class CanonUriBuilder {
+    resourceResolver;
+    constructor(resourceResolver) {
+        this.resourceResolver = resourceResolver;
+    }
+    async buildFromNameAsync(entityName, currentDocument) {
+        const result = await this.resourceResolver.resolveEntityAsync(entityName, currentDocument);
+        return result?.uri ?? null;
+    }
+    buildFromName(entityName, entityIndex, currentDocument) {
+        if (entityName.includes('.')) {
+            const parts = entityName.split('.');
+            const alias = parts[0];
+            const name = parts[1];
+            const packageName = this.findPackageNameForAlias(currentDocument, alias);
+            if (packageName) {
+                for (const result of entityIndex.values()) {
+                    if (result.entityName === name && result.uri.package_ === packageName) {
+                        return result.uri;
+                    }
+                }
+            }
+            return null;
+        }
+        const entityResult = entityIndex.get(entityName);
+        if (entityResult) {
+            return entityResult.uri;
+        }
+        return null;
+    }
+    create(publisher, package_, name, version) {
+        return new CanonUri(publisher, package_, name, version);
+    }
+    findPackageNameForAlias(document, alias) {
+        if (!document.metadata.imports) {
+            return null;
+        }
+        for (const [_publisher, imports] of Object.entries(document.metadata.imports)) {
+            for (const import_ of imports) {
+                if (import_.alias === alias) {
+                    return import_.packageName;
+                }
+                if (!import_.alias && import_.packageName === alias) {
+                    return import_.packageName;
+                }
+            }
+        }
+        return null;
+    }
+}

package/dist/resolution/ResourceResolutionResult.d.ts

@@ -0,0 +1,9 @@
+import type { CanonUri } from './CanonUri.js';
+export interface ResourceResolutionResult {
+    entityName: string;
+    uri: CanonUri;
+    entity: Record<string, any>;
+    definedInNamespace: string;
+    isImported: boolean;
+    importPath?: string;
+}

package/dist/resolution/ResourceResolutionResult.js

@@ -0,0 +1 @@
+export {};

package/dist/resolution/ResourceResolver.d.ts

@@ -0,0 +1,27 @@
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import type { ResourceResolutionResult } from './ResourceResolutionResult.js';
+export interface ILogger {
+    debug(message: string, ...args: any[]): void;
+    info(message: string, ...args: any[]): void;
+    warn(message: string, ...args: any[]): void;
+    error(message: string, error?: Error, ...args: any[]): void;
+}
+export declare class ResourceResolver {
+    private readonly cache;
+    private readonly repository;
+    private readonly logger;
+    constructor(repository: ICanonDocumentRepository, logger?: ILogger);
+    resolveEntityAsync(entityName: string, currentDocument: CanonDocument): Promise<ResourceResolutionResult | null>;
+    resolveAllEntitiesAsync(entityName: string, currentDocument: CanonDocument): Promise<ResourceResolutionResult[]>;
+    private buildAllEntitiesIndexAsync;
+    buildEntityIndexAsync(document: CanonDocument): Promise<Map<string, ResourceResolutionResult>>;
+    private buildEntityIndexAsyncInternal;
+    private findDocumentForAlias;
+    clearCache(): void;
+    clearCacheForDocument(documentKey: string): void;
+    isSubclassOfAsync(className: string, parentClassName: string, document: CanonDocument): Promise<boolean>;
+    private isSubclassOfRecursiveAsync;
+    isSubpropertyOfAsync(propertyName: string, parentPropertyName: string, document: CanonDocument): Promise<boolean>;
+    private isSubpropertyOfRecursiveAsync;
+}

package/dist/resolution/ResourceResolver.js

@@ -0,0 +1,266 @@
+import { CanonUri } from './CanonUri.js';
+import { normalizeToStringList } from '../validation/rules/normalizeToStringList.js';
+export class ResourceResolver {
+    cache = new Map();
+    repository;
+    logger;
+    constructor(repository, logger) {
+        this.repository = repository;
+        this.logger = logger;
+    }
+    async resolveEntityAsync(entityName, currentDocument) {
+        const documentKey = currentDocument.metadata?.namespace_?.toString() ?? 'unknown';
+        const docCache = this.cache.get(documentKey);
+        if (docCache) {
+            const cachedResult = docCache.get(entityName);
+            if (cachedResult) {
+                return cachedResult;
+            }
+        }
+        const entityIndex = await this.buildEntityIndexAsyncInternal(currentDocument, new Set(), '');
+        this.cache.set(documentKey, entityIndex);
+        return entityIndex.get(entityName) ?? null;
+    }
+    async resolveAllEntitiesAsync(entityName, currentDocument) {
+        const allEntities = await this.buildAllEntitiesIndexAsync(currentDocument, new Set(), '');
+        if (entityName.includes('.')) {
+            const parts = entityName.split('.');
+            const alias = parts[0];
+            const name = parts[1];
+            const aliasedDoc = await this.findDocumentForAlias(currentDocument, alias);
+            if (aliasedDoc) {
+                return await this.resolveAllEntitiesAsync(name, aliasedDoc);
+            }
+            return [];
+        }
+        return allEntities.filter(e => e.entityName === entityName);
+    }
+    async buildAllEntitiesIndexAsync(document, visitedNamespaces, importPath) {
+        const allEntities = [];
+        const currentNamespace = document.metadata?.namespace_?.toString() ?? 'unknown';
+        this.logger?.debug?.(`Building ALL entities index for namespace: ${currentNamespace}`);
+        if (visitedNamespaces.has(currentNamespace)) {
+            this.logger?.debug?.(`Skipping ${currentNamespace} - already visited (circular import prevention)`);
+            return allEntities;
+        }
+        visitedNamespaces.add(currentNamespace);
+        const currentPath = importPath.length === 0
+            ? currentNamespace
+            : `${importPath} → ${currentNamespace}`;
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (entityDef && typeof entityDef === 'object' && !Array.isArray(entityDef)) {
+                const version = document.metadata.namespace_?.version ?? {
+                    major: 1,
+                    minor: 0,
+                    patch: 0,
+                    toString: () => '1.0.0',
+                    equals: () => false,
+                    getHashCode: () => 0,
+                    compareTo: () => 0
+                };
+                allEntities.push({
+                    entityName,
+                    uri: new CanonUri(document.metadata.namespace_.publisher, document.metadata.namespace_.package_, entityName, version),
+                    entity: entityDef,
+                    definedInNamespace: currentNamespace,
+                    isImported: importPath.length > 0,
+                    importPath: currentPath
+                });
+            }
+        }
+        this.logger?.debug?.(`Collected ${allEntities.length} entities from ${currentNamespace}`);
+        if (document.metadata?.imports) {
+            const totalImports = Object.values(document.metadata.imports).reduce((sum, arr) => sum + arr.length, 0);
+            this.logger?.debug?.(`Processing ${totalImports} import(s) for ${currentNamespace}`);
+            for (const [publisher, imports] of Object.entries(document.metadata.imports)) {
+                for (const import_ of imports) {
+                    try {
+                        this.logger?.debug?.(`Resolving import: ${publisher}/${import_.packageName}`);
+                        const importedDoc = await this.repository.getHighestCompatibleVersionAsync(publisher, import_);
+                        if (importedDoc) {
+                            this.logger?.debug?.(`Successfully loaded import: ${importedDoc.metadata?.namespace_?.toString()}`);
+                            const importedEntities = await this.buildAllEntitiesIndexAsync(importedDoc, visitedNamespaces, currentPath);
+                            allEntities.push(...importedEntities);
+                            this.logger?.debug?.(`Added ${importedEntities.length} entities from import ${importedDoc.metadata?.namespace_?.toString()}`);
+                        }
+                        else {
+                            this.logger?.warn?.(`Failed to load import: ${publisher}/${import_.packageName}`);
+                        }
+                    }
+                    catch (error) {
+                        const err = error;
+                        this.logger?.error?.(`Failed to process import ${publisher}/${import_.packageName} for namespace ${currentNamespace}. Error: ${err.message}`, err);
+                        throw new Error(`Failed to process import ${publisher}/${import_.packageName} for namespace ${currentNamespace}. ` +
+                            `See inner exception for details.`, { cause: error });
+                    }
+                }
+            }
+        }
+        return allEntities;
+    }
+    async buildEntityIndexAsync(document) {
+        return await this.buildEntityIndexAsyncInternal(document, new Set(), '');
+    }
+    async buildEntityIndexAsyncInternal(document, visitedNamespaces, importPath) {
+        const index = new Map();
+        const currentNamespace = document.metadata?.namespace_?.toString() ?? 'unknown';
+        this.logger?.debug?.(`Building entity index for namespace: ${currentNamespace}`);
+        if (visitedNamespaces.has(currentNamespace)) {
+            this.logger?.debug?.(`Skipping ${currentNamespace} - already visited (circular import prevention)`);
+            return index;
+        }
+        visitedNamespaces.add(currentNamespace);
+        const currentPath = importPath.length === 0
+            ? currentNamespace
+            : `${importPath} → ${currentNamespace}`;
+        let entitiesAddedCount = 0;
+        for (const [entityName, entityDef] of Object.entries(document.body)) {
+            if (entityDef && typeof entityDef === 'object' && !Array.isArray(entityDef)) {
+                if (!index.has(entityName)) {
+                    const version = document.metadata.namespace_?.version ?? {
+                        major: 1,
+                        minor: 0,
+                        patch: 0,
+                        toString: () => '1.0.0',
+                        equals: () => false,
+                        getHashCode: () => 0,
+                        compareTo: () => 0
+                    };
+                    index.set(entityName, {
+                        entityName,
+                        uri: new CanonUri(document.metadata.namespace_.publisher, document.metadata.namespace_.package_, entityName, version),
+                        entity: entityDef,
+                        definedInNamespace: currentNamespace,
+                        isImported: importPath.length > 0,
+                        importPath: currentPath
+                    });
+                    entitiesAddedCount++;
+                }
+            }
+        }
+        this.logger?.debug?.(`Indexed ${entitiesAddedCount} entities from ${currentNamespace}`);
+        if (document.metadata?.imports) {
+            const totalImports = Object.values(document.metadata.imports).reduce((sum, arr) => sum + arr.length, 0);
+            this.logger?.debug?.(`Processing ${totalImports} import(s) for ${currentNamespace}`);
+            for (const [publisher, imports] of Object.entries(document.metadata.imports)) {
+                for (const import_ of imports) {
+                    try {
+                        this.logger?.debug?.(`Resolving import: ${publisher}/${import_.packageName}`);
+                        const importedDoc = await this.repository.getHighestCompatibleVersionAsync(publisher, import_);
+                        if (importedDoc) {
+                            this.logger?.debug?.(`Successfully loaded import: ${importedDoc.metadata?.namespace_?.toString()}`);
+                            const importedIndex = await this.buildEntityIndexAsyncInternal(importedDoc, visitedNamespaces, currentPath);
+                            let mergedCount = 0;
+                            for (const [name, result] of importedIndex.entries()) {
+                                if (!index.has(name)) {
+                                    index.set(name, result);
+                                    mergedCount++;
+                                }
+                                if (import_.alias && !name.includes('.')) {
+                                    const aliasedName = `${import_.alias}.${name}`;
+                                    if (!index.has(aliasedName)) {
+                                        index.set(aliasedName, result);
+                                        mergedCount++;
+                                    }
+                                }
+                            }
+                            this.logger?.debug?.(`Merged ${mergedCount} entities from import ${importedDoc.metadata?.namespace_?.toString()}`);
+                        }
+                        else {
+                            this.logger?.warn?.(`Failed to load import: ${publisher}/${import_.packageName}`);
+                        }
+                    }
+                    catch (error) {
+                        const err = error;
+                        this.logger?.error?.(`Failed to process import ${publisher}/${import_.packageName} for namespace ${currentNamespace}. Error: ${err.message}`, err);
+                        throw new Error(`Failed to process import ${publisher}/${import_.packageName} for namespace ${currentNamespace}. ` +
+                            `See inner exception for details.`, { cause: error });
+                    }
+                }
+            }
+        }
+        return index;
+    }
+    async findDocumentForAlias(document, alias) {
+        if (!document.metadata?.imports) {
+            return null;
+        }
+        for (const [publisher, imports] of Object.entries(document.metadata.imports)) {
+            for (const import_ of imports) {
+                if (import_.alias === alias) {
+                    return await this.repository.getHighestCompatibleVersionAsync(publisher, import_);
+                }
+                if (!import_.alias && import_.packageName === alias) {
+                    return await this.repository.getHighestCompatibleVersionAsync(publisher, import_);
+                }
+            }
+        }
+        return null;
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+    clearCacheForDocument(documentKey) {
+        this.cache.delete(documentKey);
+    }
+    async isSubclassOfAsync(className, parentClassName, document) {
+        if (className === parentClassName) {
+            return true;
+        }
+        const visited = new Set();
+        return await this.isSubclassOfRecursiveAsync(className, parentClassName, document, visited);
+    }
+    async isSubclassOfRecursiveAsync(className, parentClassName, document, visited) {
+        if (visited.has(className)) {
+            return false;
+        }
+        visited.add(className);
+        const classResolution = await this.resolveEntityAsync(className, document);
+        if (!classResolution?.entity) {
+            return false;
+        }
+        const subClassOfValue = classResolution.entity['subClassOf'];
+        if (subClassOfValue) {
+            const parentClasses = normalizeToStringList(subClassOfValue);
+            for (const parentClass of parentClasses) {
+                if (parentClass === parentClassName) {
+                    return true;
+                }
+                if (await this.isSubclassOfRecursiveAsync(parentClass, parentClassName, document, visited)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    async isSubpropertyOfAsync(propertyName, parentPropertyName, document) {
+        if (propertyName === parentPropertyName) {
+            return true;
+        }
+        const visited = new Set();
+        return await this.isSubpropertyOfRecursiveAsync(propertyName, parentPropertyName, document, visited);
+    }
+    async isSubpropertyOfRecursiveAsync(propertyName, parentPropertyName, document, visited) {
+        if (visited.has(propertyName)) {
+            return false;
+        }
+        visited.add(propertyName);
+        const propertyResolution = await this.resolveEntityAsync(propertyName, document);
+        if (!propertyResolution?.entity) {
+            return false;
+        }
+        const subPropertyOfValue = propertyResolution.entity['subPropertyOf'];
+        if (subPropertyOfValue) {
+            const parentProperties = normalizeToStringList(subPropertyOfValue);
+            for (const parentProperty of parentProperties) {
+                if (parentProperty === parentPropertyName) {
+                    return true;
+                }
+                if (await this.isSubpropertyOfRecursiveAsync(parentProperty, parentPropertyName, document, visited)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+}

package/dist/resolution/TypeResolver.d.ts

@@ -0,0 +1,15 @@
+import type { CanonDocument } from '@canon-protocol/types/document/models/types';
+import type { CanonUri } from './CanonUri.js';
+import type { ResourceResolver } from './ResourceResolver.js';
+export declare class TypeResolver {
+    private static readonly KNOWN_XSD_DATATYPES;
+    private readonly resourceResolver;
+    constructor(resourceResolver: ResourceResolver);
+    isXsdDatatype(uri: CanonUri | null | undefined): boolean;
+    isLiteralType(uri: CanonUri | null | undefined): boolean;
+    isKnownXsdDatatypeName(typeName: string): boolean;
+    isClassTypeAsync(typeName: string, currentDocument: CanonDocument): Promise<boolean>;
+    getPropertyTypeClassification(propertyType: string | null | undefined): string;
+    isEffectiveDatatypeProperty(propertyTypeClassification: string, rangeUri: CanonUri | null | undefined): boolean;
+    isEffectiveObjectProperty(propertyTypeClassification: string, rangeUri: CanonUri | null | undefined): boolean;
+}