@canon-protocol/sdk 8.0.0

package/dist/ctl/ResourceTypeClassifier.js

@@ -0,0 +1,126 @@
+const CORE_PACKAGES = new Set([
+    'canon-protocol.org/core-rdf',
+    'canon-protocol.org/core-rdfs',
+    'canon-protocol.org/core-owl',
+    'canon-protocol.org/core-xsd',
+    'canon-protocol.org/core-canon'
+]);
+const CORE_TYPE_MAP = {
+    'Class': { publisher: 'canon-protocol.org', package_: 'core-owl' },
+    'ObjectProperty': { publisher: 'canon-protocol.org', package_: 'core-owl' },
+    'DatatypeProperty': { publisher: 'canon-protocol.org', package_: 'core-owl' },
+    'AnnotationProperty': { publisher: 'canon-protocol.org', package_: 'core-owl' },
+    'Property': { publisher: 'canon-protocol.org', package_: 'core-rdf' },
+    'Datatype': { publisher: 'canon-protocol.org', package_: 'core-rdfs' },
+    'Resource': { publisher: 'canon-protocol.org', package_: 'core-rdfs' },
+    'Literal': { publisher: 'canon-protocol.org', package_: 'core-rdfs' },
+    'Thing': { publisher: 'canon-protocol.org', package_: 'core-owl' },
+    'Nothing': { publisher: 'canon-protocol.org', package_: 'core-owl' },
+};
+function getTypeUri(resource) {
+    const entityAny = resource;
+    if (entityAny.entity && typeof entityAny.entity === 'object') {
+        const typeVal = entityAny.entity['type'];
+        if (typeof typeVal === 'string') {
+            const coreMapping = CORE_TYPE_MAP[typeVal];
+            if (coreMapping) {
+                return { publisher: coreMapping.publisher, package_: coreMapping.package_, name: typeVal };
+            }
+            return { publisher: '', package_: '', name: typeVal };
+        }
+    }
+    if (entityAny.statement && Array.isArray(entityAny.statement)) {
+        for (const stmt of entityAny.statement) {
+            if (stmt.predicate?.subject?.name === 'type' && stmt.object?.subject) {
+                const subject = stmt.object.subject;
+                if ((!subject.publisher && !subject.package_) || (subject.publisher === '' && subject.package_ === '')) {
+                    const coreMapping = CORE_TYPE_MAP[subject.name];
+                    if (coreMapping) {
+                        return { publisher: coreMapping.publisher, package_: coreMapping.package_, name: subject.name };
+                    }
+                }
+                return subject;
+            }
+        }
+    }
+    return null;
+}
+function isCorePackage(publisher, package_) {
+    return CORE_PACKAGES.has(`${publisher}/${package_}`);
+}
+export class ResourceTypeClassifier {
+    static getTypeUri(resource) {
+        return getTypeUri(resource);
+    }
+    static isCoreOntologyType(uri) {
+        return isCorePackage(uri.publisher, uri.package_);
+    }
+    static isClassType(resource) {
+        const typeUri = getTypeUri(resource);
+        if (!typeUri)
+            return false;
+        return isCorePackage(typeUri.publisher, typeUri.package_) && typeUri.name === 'Class';
+    }
+    static isDatatypeType(resource) {
+        const typeUri = getTypeUri(resource);
+        if (!typeUri)
+            return false;
+        return isCorePackage(typeUri.publisher, typeUri.package_) && typeUri.name === 'Datatype';
+    }
+    static isDatatypePropertyType(resource) {
+        const typeUri = getTypeUri(resource);
+        if (!typeUri)
+            return false;
+        return isCorePackage(typeUri.publisher, typeUri.package_) && typeUri.name === 'DatatypeProperty';
+    }
+    static isObjectPropertyType(resource) {
+        const typeUri = getTypeUri(resource);
+        if (!typeUri)
+            return false;
+        return isCorePackage(typeUri.publisher, typeUri.package_) && typeUri.name === 'ObjectProperty';
+    }
+    static isAnnotationPropertyType(resource) {
+        const typeUri = getTypeUri(resource);
+        if (!typeUri)
+            return false;
+        return isCorePackage(typeUri.publisher, typeUri.package_) && typeUri.name === 'AnnotationProperty';
+    }
+    static isGenericPropertyType(resource) {
+        const typeUri = getTypeUri(resource);
+        if (!typeUri)
+            return false;
+        return isCorePackage(typeUri.publisher, typeUri.package_) && typeUri.name === 'Property';
+    }
+    static isAnyPropertyType(resource) {
+        const typeUri = getTypeUri(resource);
+        if (!typeUri)
+            return false;
+        if (!isCorePackage(typeUri.publisher, typeUri.package_))
+            return false;
+        return typeUri.name === 'Property' ||
+            typeUri.name === 'DatatypeProperty' ||
+            typeUri.name === 'ObjectProperty' ||
+            typeUri.name === 'AnnotationProperty';
+    }
+    static isSchemaDefinitionType(resource) {
+        const typeUri = getTypeUri(resource);
+        if (!typeUri)
+            return false;
+        if (!isCorePackage(typeUri.publisher, typeUri.package_))
+            return false;
+        return typeUri.name === 'Class' ||
+            typeUri.name === 'Property' ||
+            typeUri.name === 'DatatypeProperty' ||
+            typeUri.name === 'ObjectProperty' ||
+            typeUri.name === 'AnnotationProperty' ||
+            typeUri.name === 'Datatype';
+    }
+    static isInstanceOfKnownClass(resource, knownClassNames) {
+        if (ResourceTypeClassifier.isSchemaDefinitionType(resource))
+            return false;
+        const typeUri = getTypeUri(resource);
+        if (!typeUri)
+            return false;
+        return knownClassNames.has(typeUri.name);
+    }
+}

package/dist/ctl/index.d.ts

@@ -0,0 +1,12 @@
+export { CtlCanonUri } from './CtlCanonUri.js';
+export { CtlParser } from './CtlParser.js';
+export { ResourceTypeClassifier } from './ResourceTypeClassifier.js';
+export { CtlValidator } from './CtlValidator.js';
+export { CtlGraphResolver } from './CtlGraphResolver.js';
+export { CtlMarkdownRenderer } from './CtlMarkdownRenderer.js';
+export type { CtlDocument, CanonReference, CtlValidationResult, CtlValidationError } from '@canon-protocol/types/ctl/models/types';
+export type { CtlCanonUri as ICtlCanonUri, PathSegment, ResolvedImport } from '@canon-protocol/types/ctl/parsing/types';
+export type { ResolvedResourceGraph, ResolvedResource, ResolvedProperty, UnresolvedResource } from '@canon-protocol/types/ctl/resolution/types';
+export { CtlValidationErrorType, CtlValidationSeverity } from '@canon-protocol/types/ctl/models/enums';
+export { CtlCanonUriType, PathSegmentType } from '@canon-protocol/types/ctl/parsing/enums';
+export { ResolvedResourceType } from '@canon-protocol/types/ctl/resolution/enums';

package/dist/ctl/index.js

@@ -0,0 +1,9 @@
+export { CtlCanonUri } from './CtlCanonUri.js';
+export { CtlParser } from './CtlParser.js';
+export { ResourceTypeClassifier } from './ResourceTypeClassifier.js';
+export { CtlValidator } from './CtlValidator.js';
+export { CtlGraphResolver } from './CtlGraphResolver.js';
+export { CtlMarkdownRenderer } from './CtlMarkdownRenderer.js';
+export { CtlValidationErrorType, CtlValidationSeverity } from '@canon-protocol/types/ctl/models/enums';
+export { CtlCanonUriType, PathSegmentType } from '@canon-protocol/types/ctl/parsing/enums';
+export { ResolvedResourceType } from '@canon-protocol/types/ctl/resolution/enums';

package/dist/filtering/GitIgnoreFilter.d.ts

@@ -0,0 +1,7 @@
+import type { IGitIgnoreFilter } from './IGitIgnoreFilter.js';
+export declare class GitIgnoreFilter implements IGitIgnoreFilter {
+    private readonly ignoreInstance;
+    private readonly basePath;
+    constructor(basePath: string);
+    shouldIgnore(absolutePath: string): boolean;
+}

package/dist/filtering/GitIgnoreFilter.js

@@ -0,0 +1,32 @@
+import ignore from 'ignore';
+import * as fs from 'fs';
+import * as path from 'path';
+export class GitIgnoreFilter {
+    ignoreInstance;
+    basePath;
+    constructor(basePath) {
+        this.basePath = basePath;
+        const gitignorePath = path.join(basePath, '.gitignore');
+        if (fs.existsSync(gitignorePath)) {
+            try {
+                const gitignoreContent = fs.readFileSync(gitignorePath, 'utf8');
+                this.ignoreInstance = ignore();
+                this.ignoreInstance.add(gitignoreContent);
+            }
+            catch {
+                this.ignoreInstance = null;
+            }
+        }
+        else {
+            this.ignoreInstance = null;
+        }
+    }
+    shouldIgnore(absolutePath) {
+        if (!this.ignoreInstance) {
+            return false;
+        }
+        const relativePath = path.relative(this.basePath, absolutePath);
+        const normalizedPath = relativePath.split(path.sep).join('/');
+        return this.ignoreInstance.ignores(normalizedPath);
+    }
+}

package/dist/filtering/IGitIgnoreFilter.d.ts

@@ -0,0 +1,3 @@
+export interface IGitIgnoreFilter {
+    shouldIgnore(absolutePath: string): boolean;
+}

package/dist/filtering/IGitIgnoreFilter.js

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

package/dist/filtering/index.d.ts

@@ -0,0 +1,2 @@
+export type { IGitIgnoreFilter } from './IGitIgnoreFilter.js';
+export { GitIgnoreFilter } from './GitIgnoreFilter.js';

package/dist/filtering/index.js

@@ -0,0 +1 @@
+export { GitIgnoreFilter } from './GitIgnoreFilter.js';

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export { InMemoryCanonDocumentRepository, FileSystemCanonDocumentRepository, CompositeCanonDocumentRepository, RepositoryFactory, DocumentLocation, HttpCanonDocumentRepository, PublisherIndex, PublisherConfigResolver } from './repositories/index.js';
+export type { PublisherConfig } from './repositories/index.js';
+export { GitIgnoreFilter } from './filtering/index.js';
+export type { IGitIgnoreFilter } from './filtering/index.js';
+export { CanonParser, CanonObjectParser, PropertyMetadata } from './parsing/index.js';
+export type { ICanonObjectParser } from './parsing/index.js';
+export { ResourceResolver, CanonUri, CanonUriBuilder, TypeResolver } from './resolution/index.js';
+export type { ResourceResolutionResult, ILogger } from './resolution/index.js';
+export { Canon, DefinedCanon, SubjectCanon, EmbeddedCanon, ReferenceCanon } from './canons/index.js';
+export type { IStatement } from './statements/index.js';
+export { Statement, ScalarStatement, StringStatement, NumberStatement, BooleanStatement, ReferenceStatement, EmbeddedStatement, ListStatement } from './statements/index.js';
+export { OntologyValidationResult, OntologyValidationError, ValidationSeverity, ValidationContext, CanonObjectValidator, NamespacePrefixRule, ResourceNamingRule, PropertyTypeSpecificityRule, SubjectCanonTypeRequiredRule, EmbeddedCanonNoExplicitTypeRule, ImportExistenceRule, UnresolvedReferenceRule, TypeAmbiguityRule, ClassHierarchyCycleRule, PropertyHierarchyCycleRule, PropertyRangeRequiredRule, SubClassOfReferenceRule, SubPropertyOfReferenceRule, NamespaceImportCycleRule, InstancePropertyReferenceRule, DefinitionPropertyReferenceRule, XsdImportRule, AmbiguousReferenceRule, PropertyRangeReferenceRule, ObjectPropertyImportRule, ObjectPropertyValueValidationRule, PropertyDomainRule, PropertyValueTypeRule, ClassDefinitionRule } from './validation/index.js';
+export type { ICanonObjectValidator, IDocumentValidationRule, IRepositoryValidationRule } from './validation/index.js';
+export type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+export type { ICanonParser } from '@canon-protocol/types/document/parsing';
+export type { CanonDocument, CanonMetadata, Namespace, Import, Version, DocumentReference, ParseResult, ParseError } from '@canon-protocol/types/document/models/types';
+export type { VersionOperator } from '@canon-protocol/types/document/models/enums';
+export { CtlCanonUri, CtlParser, ResourceTypeClassifier, CtlValidator, CtlGraphResolver, CtlMarkdownRenderer, CtlValidationErrorType, CtlValidationSeverity, CtlCanonUriType, PathSegmentType, ResolvedResourceType } from './ctl/index.js';
+export type { CtlDocument, CanonReference, CtlValidationResult, CtlValidationError, ResolvedResourceGraph, ResolvedResource, ResolvedProperty, UnresolvedResource } from './ctl/index.js';

package/dist/index.js

@@ -0,0 +1,8 @@
+export { InMemoryCanonDocumentRepository, FileSystemCanonDocumentRepository, CompositeCanonDocumentRepository, RepositoryFactory, DocumentLocation, HttpCanonDocumentRepository, PublisherIndex, PublisherConfigResolver } from './repositories/index.js';
+export { GitIgnoreFilter } from './filtering/index.js';
+export { CanonParser, CanonObjectParser, PropertyMetadata } from './parsing/index.js';
+export { ResourceResolver, CanonUri, CanonUriBuilder, TypeResolver } from './resolution/index.js';
+export { Canon, DefinedCanon, SubjectCanon, EmbeddedCanon, ReferenceCanon } from './canons/index.js';
+export { Statement, ScalarStatement, StringStatement, NumberStatement, BooleanStatement, ReferenceStatement, EmbeddedStatement, ListStatement } from './statements/index.js';
+export { OntologyValidationResult, OntologyValidationError, ValidationSeverity, ValidationContext, CanonObjectValidator, NamespacePrefixRule, ResourceNamingRule, PropertyTypeSpecificityRule, SubjectCanonTypeRequiredRule, EmbeddedCanonNoExplicitTypeRule, ImportExistenceRule, UnresolvedReferenceRule, TypeAmbiguityRule, ClassHierarchyCycleRule, PropertyHierarchyCycleRule, PropertyRangeRequiredRule, SubClassOfReferenceRule, SubPropertyOfReferenceRule, NamespaceImportCycleRule, InstancePropertyReferenceRule, DefinitionPropertyReferenceRule, XsdImportRule, AmbiguousReferenceRule, PropertyRangeReferenceRule, ObjectPropertyImportRule, ObjectPropertyValueValidationRule, PropertyDomainRule, PropertyValueTypeRule, ClassDefinitionRule } from './validation/index.js';
+export { CtlCanonUri, CtlParser, ResourceTypeClassifier, CtlValidator, CtlGraphResolver, CtlMarkdownRenderer, CtlValidationErrorType, CtlValidationSeverity, CtlCanonUriType, PathSegmentType, ResolvedResourceType } from './ctl/index.js';

package/dist/parsing/CanonObjectParser.d.ts

@@ -0,0 +1,21 @@
+import type { ICanonObjectParser } from './ICanonObjectParser.js';
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+import { Canon } from '../canons/Canon.js';
+import type { ICanonParser } from '@canon-protocol/types/document/parsing';
+export declare class CanonObjectParser implements ICanonObjectParser {
+    constructor(_canonParser?: ICanonParser);
+    parseCanons(documentRepository: ICanonDocumentRepository): Promise<Canon[]>;
+    private parseStatements;
+    private getPropertyMetadata;
+    private parsePropertyValue;
+    private parseDatatypeValue;
+    private parseObjectValue;
+    private parseListValue;
+    saveCanons(canons: Canon[], documentRepository: ICanonDocumentRepository): Promise<void>;
+    serializeToYaml(canons: Canon[], namespaceString: string): Promise<string>;
+    private convertCanonsToDocument;
+    private convertStatementToProperty;
+    private convertCanonListToValue;
+    private convertEmbeddedCanonToValue;
+    private collectImportsFromStatement;
+}

package/dist/parsing/CanonObjectParser.js

@@ -0,0 +1,242 @@
+import { SubjectCanon } from '../canons/SubjectCanon.js';
+import { EmbeddedCanon } from '../canons/EmbeddedCanon.js';
+import { ReferenceCanon } from '../canons/ReferenceCanon.js';
+import { StringStatement } from '../statements/StringStatement.js';
+import { NumberStatement } from '../statements/NumberStatement.js';
+import { BooleanStatement } from '../statements/BooleanStatement.js';
+import { ReferenceStatement } from '../statements/ReferenceStatement.js';
+import { EmbeddedStatement } from '../statements/EmbeddedStatement.js';
+import { ListStatement } from '../statements/ListStatement.js';
+import { ResourceResolver } from '../resolution/ResourceResolver.js';
+import { TypeResolver } from '../resolution/TypeResolver.js';
+import { CanonParser } from './CanonParser.js';
+export class CanonObjectParser {
+    constructor(_canonParser) {
+    }
+    async parseCanons(documentRepository) {
+        const canons = [];
+        const documents = await documentRepository.getAllDocumentsAsync();
+        const resourceResolver = new ResourceResolver(documentRepository);
+        const typeResolver = new TypeResolver(resourceResolver);
+        for (const document of documents) {
+            for (const [entityName, entityValue] of Object.entries(document.body)) {
+                const subject = new SubjectCanon();
+                subject.namespace = document.metadata.namespace_?.toString() ?? '';
+                subject.name = entityName;
+                subject.statement = [];
+                const statements = await this.parseStatements(entityValue, document, resourceResolver, typeResolver, documentRepository);
+                subject.statement.push(...statements);
+                canons.push(subject);
+            }
+        }
+        return canons;
+    }
+    async parseStatements(entityValue, document, resourceResolver, typeResolver, repository) {
+        const statements = [];
+        if (typeof entityValue !== 'object' || entityValue === null || Array.isArray(entityValue)) {
+            return statements;
+        }
+        for (const [propertyName, propertyValue] of Object.entries(entityValue)) {
+            try {
+                const metadata = await this.getPropertyMetadata(propertyName, document, resourceResolver, repository);
+                if (!metadata) {
+                    continue;
+                }
+                const statement = await this.parsePropertyValue(propertyName, propertyValue, metadata, document, resourceResolver, typeResolver);
+                if (statement) {
+                    statements.push(statement);
+                }
+            }
+            catch (error) {
+                console.error(`Error parsing property ${propertyName}:`, error);
+            }
+        }
+        return statements;
+    }
+    async getPropertyMetadata(propertyName, document, resourceResolver, _repository) {
+        const propertyResolution = await resourceResolver.resolveEntityAsync(propertyName, document);
+        if (!propertyResolution) {
+            return undefined;
+        }
+        const propertyDef = propertyResolution.entity;
+        const type = propertyDef.type?.toString() ?? '';
+        const propertyType = type === 'ObjectProperty' ? 'ObjectProperty' : 'DatatypeProperty';
+        const range = propertyDef.range?.toString();
+        const metadata = {
+            propertyUri: propertyResolution.uri.toString(),
+            propertyType,
+            range,
+            isImported: propertyResolution.isImported,
+            definedInNamespace: propertyResolution.definedInNamespace
+        };
+        return metadata;
+    }
+    async parsePropertyValue(_propertyName, value, metadata, document, resourceResolver, typeResolver) {
+        const predicateUri = metadata.propertyUri;
+        if (value === null || value === undefined) {
+            return undefined;
+        }
+        if (Array.isArray(value)) {
+            return this.parseListValue(predicateUri, value, metadata, document, resourceResolver, typeResolver);
+        }
+        if (metadata.propertyType === 'DatatypeProperty') {
+            return this.parseDatatypeValue(predicateUri, value, metadata);
+        }
+        if (metadata.propertyType === 'ObjectProperty') {
+            return this.parseObjectValue(predicateUri, value, metadata, document, resourceResolver, typeResolver);
+        }
+        return undefined;
+    }
+    parseDatatypeValue(predicateUri, value, _metadata) {
+        if (typeof value === 'string') {
+            return StringStatement.parse(predicateUri, value);
+        }
+        else if (typeof value === 'number') {
+            return NumberStatement.parse(predicateUri, value);
+        }
+        else if (typeof value === 'boolean') {
+            const stmt = new BooleanStatement();
+            stmt.predicate = ReferenceCanon.parse(predicateUri);
+            stmt.object = value;
+            return stmt;
+        }
+        return undefined;
+    }
+    async parseObjectValue(predicateUri, value, _metadata, document, resourceResolver, typeResolver) {
+        if (typeof value === 'string') {
+            return ReferenceStatement.parse(predicateUri, value);
+        }
+        if (typeof value === 'object' && !Array.isArray(value)) {
+            const embedded = new EmbeddedCanon();
+            embedded.statement = await this.parseStatements(value, document, resourceResolver, typeResolver, {} // TODO: Pass actual repository
+            );
+            const stmt = new EmbeddedStatement();
+            stmt.predicate = ReferenceCanon.parse(predicateUri);
+            stmt.object = embedded;
+            return stmt;
+        }
+        return undefined;
+    }
+    async parseListValue(predicateUri, values, _metadata, document, resourceResolver, typeResolver) {
+        const canons = [];
+        for (const item of values) {
+            if (typeof item === 'string') {
+                canons.push(ReferenceCanon.parse(item));
+            }
+            else if (typeof item === 'object' && !Array.isArray(item)) {
+                const embedded = new EmbeddedCanon();
+                embedded.statement = await this.parseStatements(item, document, resourceResolver, typeResolver, {} // TODO: Pass actual repository
+                );
+                canons.push(embedded);
+            }
+        }
+        const stmt = new ListStatement();
+        stmt.predicate = ReferenceCanon.parse(predicateUri);
+        stmt.object = canons;
+        return stmt;
+    }
+    async saveCanons(canons, documentRepository) {
+        const canonsByNamespace = new Map();
+        for (const canon of canons) {
+            if (canon instanceof SubjectCanon && canon.namespace) {
+                if (!canonsByNamespace.has(canon.namespace)) {
+                    canonsByNamespace.set(canon.namespace, []);
+                }
+                canonsByNamespace.get(canon.namespace).push(canon);
+            }
+        }
+        for (const [namespace, groupCanons] of canonsByNamespace) {
+            const document = await this.convertCanonsToDocument(namespace, groupCanons);
+            const identifier = `${namespace.split('@')[0]}.yml`;
+            await documentRepository.saveDocumentAsync(document, identifier);
+        }
+    }
+    async serializeToYaml(canons, namespaceString) {
+        const filteredCanons = canons
+            .filter((c) => c instanceof SubjectCanon && c.namespace === namespaceString);
+        if (filteredCanons.length === 0) {
+            throw new Error(`No canons found with namespace '${namespaceString}'`);
+        }
+        const document = await this.convertCanonsToDocument(namespaceString, filteredCanons);
+        const parser = new CanonParser();
+        return parser.save(document);
+    }
+    async convertCanonsToDocument(namespaceString, canons) {
+        const metadata = {
+            namespace_: namespaceString, // Will be parsed properly
+            get allImports() {
+                if (!this.imports)
+                    return [];
+                const result = [];
+                for (const importList of Object.values(this.imports)) {
+                    result.push(...importList);
+                }
+                return result;
+            }
+        };
+        const document = {
+            metadata,
+            body: {}
+        };
+        const imports = new Map();
+        for (const canon of canons) {
+            const bodyEntry = {};
+            for (const statement of canon.statement) {
+                const [propertyName, propertyValue] = this.convertStatementToProperty(statement);
+                if (propertyName && propertyValue !== null && propertyValue !== undefined) {
+                    bodyEntry[propertyName] = propertyValue;
+                }
+                this.collectImportsFromStatement(statement, namespaceString, imports);
+            }
+            document.body[canon.name] = bodyEntry;
+        }
+        return document;
+    }
+    convertStatementToProperty(statement) {
+        if (statement instanceof StringStatement) {
+            return [statement.predicate.subject.name, statement.object];
+        }
+        else if (statement instanceof NumberStatement) {
+            return [statement.predicate.subject.name, statement.object];
+        }
+        else if (statement instanceof BooleanStatement) {
+            return [statement.predicate.subject.name, statement.object];
+        }
+        else if (statement instanceof ReferenceStatement) {
+            return [statement.predicate.subject.name, statement.object.subject.name];
+        }
+        else if (statement instanceof ListStatement) {
+            const listValue = this.convertCanonListToValue(statement.object);
+            return [statement.predicate.subject.name, listValue];
+        }
+        else if (statement instanceof EmbeddedStatement) {
+            const embeddedValue = this.convertEmbeddedCanonToValue(statement.object);
+            return [statement.predicate.subject.name, embeddedValue];
+        }
+        return [null, null];
+    }
+    convertCanonListToValue(canonList) {
+        const result = [];
+        for (const canon of canonList) {
+            if (canon instanceof ReferenceCanon) {
+                result.push(canon.subject.name);
+            }
+            else if (canon instanceof EmbeddedCanon) {
+                result.push(this.convertEmbeddedCanonToValue(canon));
+            }
+        }
+        return result;
+    }
+    convertEmbeddedCanonToValue(embeddedCanon) {
+        const result = {};
+        for (const statement of embeddedCanon.statement) {
+            const [propertyName, propertyValue] = this.convertStatementToProperty(statement);
+            if (propertyName && propertyValue !== null && propertyValue !== undefined) {
+                result[propertyName] = propertyValue;
+            }
+        }
+        return result;
+    }
+    collectImportsFromStatement(_statement, _currentNamespace, _imports) {
+    }
+}

package/dist/parsing/CanonParser.d.ts

@@ -0,0 +1,21 @@
+import type { CanonDocument, ParseResult } from '@canon-protocol/types/document/models/types';
+import type { ICanonParser } from '@canon-protocol/types/document/parsing';
+export declare class CanonParser implements ICanonParser {
+    parse(yamlText: string): CanonDocument;
+    parseWithErrors(yamlText: string): ParseResult;
+    save(document: CanonDocument): string;
+    private createEmptyMetadata;
+    private addAllImportsGetter;
+    private createVersion;
+    private extractMetadata;
+    private extractBody;
+    private parseNamespace;
+    private parseVersion;
+    private parseImportsV3;
+    private parseImportsLegacy;
+    private parseImportFromEmbeddedObject;
+    private parseImport;
+    private parseVersionOperator;
+    private calculateMaxVersion;
+    private serializeImports;
+}