@canon-protocol/sdk 8.0.0

package/dist/canons/Canon.d.ts

@@ -0,0 +1,2 @@
+export declare abstract class Canon {
+}

package/dist/canons/Canon.js

@@ -0,0 +1,2 @@
+export class Canon {
+}

package/dist/canons/DefinedCanon.d.ts

@@ -0,0 +1,5 @@
+import { Canon } from './Canon.js';
+import type { IStatement } from '../statements/IStatement.js';
+export declare abstract class DefinedCanon extends Canon {
+    statement: IStatement[];
+}

package/dist/canons/DefinedCanon.js

@@ -0,0 +1,4 @@
+import { Canon } from './Canon.js';
+export class DefinedCanon extends Canon {
+    statement = [];
+}

package/dist/canons/EmbeddedCanon.d.ts

@@ -0,0 +1,3 @@
+import { DefinedCanon } from './DefinedCanon.js';
+export declare class EmbeddedCanon extends DefinedCanon {
+}

package/dist/canons/EmbeddedCanon.js

@@ -0,0 +1,3 @@
+import { DefinedCanon } from './DefinedCanon.js';
+export class EmbeddedCanon extends DefinedCanon {
+}

package/dist/canons/ReferenceCanon.d.ts

@@ -0,0 +1,6 @@
+import { Canon } from './Canon.js';
+import { CanonUri } from '../resolution/CanonUri.js';
+export declare class ReferenceCanon extends Canon {
+    subject: CanonUri;
+    static parse(subjectCanonUri: string): ReferenceCanon;
+}

package/dist/canons/ReferenceCanon.js

@@ -0,0 +1,10 @@
+import { Canon } from './Canon.js';
+import { CanonUri } from '../resolution/CanonUri.js';
+export class ReferenceCanon extends Canon {
+    subject;
+    static parse(subjectCanonUri) {
+        const canon = new ReferenceCanon();
+        canon.subject = CanonUri.parse(subjectCanonUri);
+        return canon;
+    }
+}

package/dist/canons/SubjectCanon.d.ts

@@ -0,0 +1,6 @@
+import { DefinedCanon } from './DefinedCanon.js';
+export declare class SubjectCanon extends DefinedCanon {
+    namespace: string;
+    name: string;
+    icon?: string;
+}

package/dist/canons/SubjectCanon.js

@@ -0,0 +1,6 @@
+import { DefinedCanon } from './DefinedCanon.js';
+export class SubjectCanon extends DefinedCanon {
+    namespace;
+    name;
+    icon;
+}

package/dist/canons/index.d.ts

@@ -0,0 +1,5 @@
+export { Canon } from './Canon.js';
+export { DefinedCanon } from './DefinedCanon.js';
+export { SubjectCanon } from './SubjectCanon.js';
+export { EmbeddedCanon } from './EmbeddedCanon.js';
+export { ReferenceCanon } from './ReferenceCanon.js';

package/dist/canons/index.js

@@ -0,0 +1,5 @@
+export { Canon } from './Canon.js';
+export { DefinedCanon } from './DefinedCanon.js';
+export { SubjectCanon } from './SubjectCanon.js';
+export { EmbeddedCanon } from './EmbeddedCanon.js';
+export { ReferenceCanon } from './ReferenceCanon.js';

package/dist/ctl/CtlCanonUri.d.ts

@@ -0,0 +1,28 @@
+import type { CtlCanonUri as ICtlCanonUri, PathSegment } from '@canon-protocol/types/ctl/parsing/types';
+import { CtlCanonUriType } from '@canon-protocol/types/ctl/parsing/enums';
+import type { Version } from '@canon-protocol/types/document/models/types';
+export declare class CtlCanonUri implements ICtlCanonUri {
+    readonly scheme: string;
+    publisher: string;
+    package_?: string | null | undefined;
+    version?: Version | null | undefined;
+    resourceName?: string | null | undefined;
+    path: readonly PathSegment[];
+    rawUri: string;
+    constructor(init: {
+        publisher: string;
+        package_?: string | null | undefined;
+        version?: Version | null | undefined;
+        resourceName?: string | null | undefined;
+        path?: PathSegment[];
+        rawUri: string;
+    });
+    get uriType(): CtlCanonUriType;
+    get namespace_(): string | null;
+    static parse(uriString: string): CtlCanonUri;
+    static tryParse(uriString: string): CtlCanonUri | null;
+    static isCanonUri(value: string): boolean;
+    toString(): string;
+    equals(obj: any): boolean;
+    getHashCode(): number;
+}

package/dist/ctl/CtlCanonUri.js

@@ -0,0 +1,230 @@
+import { CtlCanonUriType, PathSegmentType } from '@canon-protocol/types/ctl/parsing/enums';
+const PATH_SEGMENT_REGEX = /\.?([a-zA-Z_][a-zA-Z0-9_-]*|\[\d+\])/g;
+function parseVersion(versionStr) {
+    const parts = versionStr.split('.').map(Number);
+    const major = parts[0] || 0;
+    const minor = parts[1] || 0;
+    const patch = parts[2] || 0;
+    return {
+        major,
+        minor,
+        patch,
+        toString: () => `${major}.${minor}.${patch}`,
+        equals: (obj) => obj && typeof obj === 'object' &&
+            obj.major === major && obj.minor === minor && obj.patch === patch,
+        getHashCode: () => (major << 20) | (minor << 10) | patch,
+        compareTo: (other) => {
+            if (major !== other.major)
+                return major - other.major;
+            if (minor !== other.minor)
+                return minor - other.minor;
+            return patch - other.patch;
+        }
+    };
+}
+export class CtlCanonUri {
+    scheme = 'canon';
+    publisher;
+    package_;
+    version;
+    resourceName;
+    path;
+    rawUri;
+    constructor(init) {
+        this.publisher = init.publisher;
+        this.package_ = init.package_;
+        this.version = init.version;
+        this.resourceName = init.resourceName;
+        this.path = init.path ?? [];
+        this.rawUri = init.rawUri;
+    }
+    get uriType() {
+        if (this.path.length > 0)
+            return CtlCanonUriType.DeepLink;
+        if (this.resourceName != null)
+            return CtlCanonUriType.Resource;
+        if (this.version != null)
+            return CtlCanonUriType.VersionedPackage;
+        if (this.package_ != null)
+            return CtlCanonUriType.Package;
+        return CtlCanonUriType.Publisher;
+    }
+    get namespace_() {
+        if (this.package_ == null)
+            return null;
+        if (this.version == null)
+            return `${this.publisher}/${this.package_}`;
+        return `${this.publisher}/${this.package_}@${this.version}`;
+    }
+    static parse(uriString) {
+        if (!uriString || uriString.trim().length === 0) {
+            throw new Error('Canon URI string cannot be null or empty');
+        }
+        if (!uriString.toLowerCase().startsWith('canon://')) {
+            throw new Error(`Invalid Canon URI: '${uriString}'. Must start with 'canon://'`);
+        }
+        const remainder = uriString.substring(8); // Remove "canon://"
+        if (!remainder || remainder.trim().length === 0) {
+            throw new Error(`Invalid Canon URI: '${uriString}'. Publisher is required after 'canon://'`);
+        }
+        const fragmentIndex = remainder.indexOf('#');
+        let fragment = null;
+        let resourcePart;
+        if (fragmentIndex >= 0) {
+            resourcePart = remainder.substring(0, fragmentIndex);
+            fragment = remainder.substring(fragmentIndex + 1);
+            if (!fragment || fragment.trim().length === 0) {
+                throw new Error(`Invalid Canon URI: '${uriString}'. Deep link path required after '#'`);
+            }
+        }
+        else {
+            resourcePart = remainder;
+        }
+        let publisher;
+        let package_ = null;
+        let version = null;
+        let resourceName = null;
+        const atIndex = resourcePart.indexOf('@');
+        if (atIndex >= 0) {
+            const beforeAt = resourcePart.substring(0, atIndex);
+            const afterAt = resourcePart.substring(atIndex + 1);
+            const slashIndex = beforeAt.indexOf('/');
+            if (slashIndex < 0) {
+                throw new Error(`Invalid Canon URI: '${uriString}'. Expected format: publisher/package@version/resource`);
+            }
+            publisher = beforeAt.substring(0, slashIndex);
+            package_ = beforeAt.substring(slashIndex + 1);
+            if (!publisher || publisher.trim().length === 0) {
+                throw new Error(`Invalid Canon URI: '${uriString}'. Publisher cannot be empty`);
+            }
+            if (!package_ || package_.trim().length === 0) {
+                throw new Error(`Invalid Canon URI: '${uriString}'. Package cannot be empty`);
+            }
+            const versionSlashIndex = afterAt.indexOf('/');
+            if (versionSlashIndex < 0) {
+                throw new Error(`Invalid Canon URI: '${uriString}'. CTL requires resource references (canon://publisher/package@version/resource)`);
+            }
+            const versionStr = afterAt.substring(0, versionSlashIndex);
+            resourceName = afterAt.substring(versionSlashIndex + 1);
+            if (!versionStr || versionStr.trim().length === 0) {
+                throw new Error(`Invalid Canon URI: '${uriString}'. Version required after '@'`);
+            }
+            version = parseVersion(versionStr);
+            if (!resourceName || resourceName.trim().length === 0) {
+                throw new Error(`Invalid Canon URI: '${uriString}'. Resource name cannot be empty`);
+            }
+        }
+        else {
+            const segments = resourcePart.split('/');
+            if (segments.length < 3) {
+                throw new Error(`Invalid Canon URI: '${uriString}'. CTL requires resource references (canon://publisher/package/resource)`);
+            }
+            if (segments.length > 3) {
+                throw new Error(`Invalid Canon URI: '${uriString}'. Too many path segments. Expected: publisher/package/resource`);
+            }
+            publisher = segments[0];
+            package_ = segments[1];
+            resourceName = segments[2];
+            if (!publisher || publisher.trim().length === 0) {
+                throw new Error(`Invalid Canon URI: '${uriString}'. Publisher cannot be empty`);
+            }
+            if (!package_ || package_.trim().length === 0) {
+                throw new Error(`Invalid Canon URI: '${uriString}'. Package cannot be empty`);
+            }
+            if (!resourceName || resourceName.trim().length === 0) {
+                throw new Error(`Invalid Canon URI: '${uriString}'. Resource name cannot be empty`);
+            }
+        }
+        let pathSegments = [];
+        if (fragment != null) {
+            pathSegments = parsePath(fragment, uriString);
+        }
+        return new CtlCanonUri({
+            publisher,
+            package_,
+            version,
+            resourceName,
+            path: pathSegments,
+            rawUri: uriString
+        });
+    }
+    static tryParse(uriString) {
+        try {
+            return CtlCanonUri.parse(uriString);
+        }
+        catch {
+            return null;
+        }
+    }
+    static isCanonUri(value) {
+        return !!value && value.trim().length > 0 &&
+            value.toLowerCase().startsWith('canon://');
+    }
+    toString() {
+        let result = `canon://${this.publisher}`;
+        if (this.package_ != null) {
+            result += `/${this.package_}`;
+            if (this.version != null) {
+                result += `@${this.version}`;
+            }
+            if (this.resourceName != null) {
+                result += `/${this.resourceName}`;
+                if (this.path.length > 0) {
+                    result += '#';
+                    let first = true;
+                    for (const segment of this.path) {
+                        if (segment.type_ === PathSegmentType.Index) {
+                            result += `[${segment.index}]`;
+                        }
+                        else {
+                            if (!first)
+                                result += '.';
+                            result += segment.name;
+                        }
+                        first = false;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    equals(obj) {
+        if (!(obj instanceof CtlCanonUri))
+            return false;
+        return this.rawUri.toLowerCase() === obj.rawUri.toLowerCase();
+    }
+    getHashCode() {
+        let hash = 0;
+        const s = this.rawUri.toLowerCase();
+        for (let i = 0; i < s.length; i++) {
+            hash = ((hash << 5) - hash) + s.charCodeAt(i);
+            hash |= 0;
+        }
+        return hash;
+    }
+}
+function parsePath(pathPortion, originalUri) {
+    const segments = [];
+    const regex = new RegExp(PATH_SEGMENT_REGEX.source, 'g');
+    let totalMatchedLength = 0;
+    let match;
+    while ((match = regex.exec(pathPortion)) !== null) {
+        const segment = match[1];
+        if (segment.startsWith('[') && segment.endsWith(']')) {
+            const indexStr = segment.substring(1, segment.length - 1);
+            const index = parseInt(indexStr, 10);
+            if (isNaN(index)) {
+                throw new Error(`Invalid Canon URI: '${originalUri}'. Invalid array index: ${segment}`);
+            }
+            segments.push({ type_: PathSegmentType.Index, index, toString: () => `[${index}]` });
+        }
+        else {
+            segments.push({ type_: PathSegmentType.Property, name: segment, toString: () => segment });
+        }
+        totalMatchedLength += match[0].length;
+    }
+    if (totalMatchedLength !== pathPortion.length) {
+        throw new Error(`Invalid Canon URI: '${originalUri}'. Invalid path syntax in: ${pathPortion}`);
+    }
+    return segments;
+}

package/dist/ctl/CtlGraphResolver.d.ts

@@ -0,0 +1,14 @@
+import type { CtlDocument } from '@canon-protocol/types/ctl/models/types';
+import type { ResolvedResourceGraph, CtlGraphResolver as ICtlGraphResolver } from '@canon-protocol/types/ctl/resolution/types';
+import type { ICanonDocumentRepository } from '@canon-protocol/types/document/models';
+export declare class CtlGraphResolver implements ICtlGraphResolver {
+    private readonly repository;
+    constructor(repository: ICanonDocumentRepository);
+    resolveAsync(document: CtlDocument, maxDepth?: number): Promise<ResolvedResourceGraph>;
+    private resolveEntityRecursive;
+    private createResolvedResource;
+    private classifyEntityType;
+    private classifyTier;
+    private resolveReferenceToUri;
+    private createMockSubjectCanon;
+}