@kubun/id 0.10.0 → 0.12.0

package/lib/attachment.d.ts

@@ -1,5 +1,5 @@
-import { AttachmentType, KubunID } from './base.js';
-export declare class AttachmentID extends KubunID<AttachmentType.BINARY> {
+import { ATTACHMENT_BINARY, KubunID } from './base.js';
+export declare class AttachmentID extends KubunID<typeof ATTACHMENT_BINARY> {
     #private;
     static create(value: Uint8Array, mimeType?: string): AttachmentID;
     static fromBytes(input: Uint8Array): AttachmentID;

package/lib/attachment.js

@@ -1 +1,96 @@
-import{fromUTF as t,toUTF as e}from"@enkaku/codec";import{base36 as r}from"multiformats/bases/base36";import{AttachmentType as n,KubunID as i,NAMESPACE_CODE as s}from"./base.js";import{concat as m}from"./bytes.js";import{decodeVarint as o,digestBytes as c,encodeVarint as a}from"./utils.js";let h="application/octet-stream";export class AttachmentID extends i{static create(t,e){return new AttachmentID(c(t),t.byteLength,e)}static fromBytes(t){let r=0,[i,m]=o(t);if(i!==s)throw Error("Invalid KubunID: namespace mismatch");let[c,a]=o(t,r+=m);if(c!==n.BINARY)throw Error("Invalid KubunID: type mismatch");let[h,f]=o(t,r+=a);r+=f;let p=t.slice(r,r+h),[u,g]=o(t,r+=h),[l,y]=o(t,r+=g);return 0===l?new AttachmentID(p,u):(r+=y,new AttachmentID(p,u,e(t.slice(r,r+l))))}static fromString(t){return AttachmentID.fromBytes(r.decode(t))}static from(t){if(t instanceof AttachmentID)return t;if(t instanceof Uint8Array)return AttachmentID.fromBytes(t);if("string"==typeof t)return AttachmentID.fromString(t);throw Error("Unsupported input type")}#t;#e;#r;constructor(e,r,i=h){let s,o=m([a(e.byteLength),e,a(r)]);if(i===h)s=m([o,a(0)]);else{let e=t(i);s=m([o,a(e.byteLength),e])}super(n.BINARY,s),this.#t=r,this.#e=e,this.#r=i}get contentLength(){return this.#t}get digest(){return this.#e}get mimeType(){return this.#r}}
+import { fromUTF, toUTF } from '@sozai/codec';
+import { base36 } from 'multiformats/bases/base36';
+import { ATTACHMENT_BINARY, KubunID, NAMESPACE_CODE } from './base.js';
+import { concat } from './bytes.js';
+import { decodeVarint, digestBytes, encodeVarint } from './utils.js';
+const DEFAULT_MIME_TYPE = 'application/octet-stream';
+export class AttachmentID extends KubunID {
+    static create(value, mimeType) {
+        return new AttachmentID(digestBytes(value), value.byteLength, mimeType);
+    }
+    static fromBytes(input) {
+        let offset = 0;
+        // Check namespace = is it a KubunID?
+        const [namespace, namespaceLength] = decodeVarint(input);
+        if (namespace !== NAMESPACE_CODE) {
+            throw new Error('Invalid KubunID: namespace mismatch');
+        }
+        offset += namespaceLength;
+        // Check type matches
+        const [type, typeLength] = decodeVarint(input, offset);
+        if (type !== ATTACHMENT_BINARY) {
+            throw new Error('Invalid KubunID: type mismatch');
+        }
+        offset += typeLength;
+        // Decode digest
+        const [digestLength, digestVarintLength] = decodeVarint(input, offset);
+        offset += digestVarintLength;
+        const digest = input.slice(offset, offset + digestLength);
+        offset += digestLength;
+        // Extract content length
+        const [contentLength, contentVarintLength] = decodeVarint(input, offset);
+        offset += contentVarintLength;
+        // Check if MIME type is provided
+        const [mimeTypeBytesLength, mimeTypeVarintLength] = decodeVarint(input, offset);
+        if (mimeTypeBytesLength === 0) {
+            // No MIME type encoded, use default
+            return new AttachmentID(digest, contentLength);
+        }
+        // Decode MIME type value
+        offset += mimeTypeVarintLength;
+        const mimeTypeBytes = input.slice(offset, offset + mimeTypeBytesLength);
+        return new AttachmentID(digest, contentLength, toUTF(mimeTypeBytes));
+    }
+    static fromString(input) {
+        return AttachmentID.fromBytes(base36.decode(input));
+    }
+    static from(input) {
+        if (input instanceof AttachmentID) {
+            return input;
+        }
+        if (input instanceof Uint8Array) {
+            return AttachmentID.fromBytes(input);
+        }
+        if (typeof input === 'string') {
+            return AttachmentID.fromString(input);
+        }
+        throw new Error('Unsupported input type');
+    }
+    #contentLength;
+    #digest;
+    #mimeType;
+    constructor(digest, contentLength, mimeType = DEFAULT_MIME_TYPE){
+        let data;
+        const baseData = concat([
+            encodeVarint(digest.byteLength),
+            digest,
+            encodeVarint(contentLength)
+        ]);
+        if (mimeType === DEFAULT_MIME_TYPE) {
+            data = concat([
+                baseData,
+                encodeVarint(0)
+            ]);
+        } else {
+            const typeBytes = fromUTF(mimeType);
+            data = concat([
+                baseData,
+                encodeVarint(typeBytes.byteLength),
+                typeBytes
+            ]);
+        }
+        super(ATTACHMENT_BINARY, data);
+        this.#contentLength = contentLength;
+        this.#digest = digest;
+        this.#mimeType = mimeType;
+    }
+    get contentLength() {
+        return this.#contentLength;
+    }
+    get digest() {
+        return this.#digest;
+    }
+    get mimeType() {
+        return this.#mimeType;
+    }
+}

package/lib/base.d.ts

@@ -1,19 +1,24 @@
 export declare const NAMESPACE_CODE = 181;
-export declare enum AttachmentType {
-    BINARY = 1
-}
-export declare enum ModelType {
-    SCALAR = 10,
-    SHAPE = 11,
-    DOCUMENT = 20,
-    CLUSTER = 21
-}
-export declare enum DocumentType {
-    MERGE_DOCUMENT = 30
-}
-export declare enum ExternalType {
-    PLUGIN_NODE = 40
-}
+/**
+ * Immutable references
+ */
+export declare const ATTACHMENT_BINARY = 1;
+export type AttachmentType = typeof ATTACHMENT_BINARY;
+export declare const MODEL_SCALAR = 10;
+export declare const MODEL_SHAPE = 11;
+export declare const MODEL_DOCUMENT = 20;
+export declare const MODEL_CLUSTER = 21;
+export type ModelType = typeof MODEL_SCALAR | typeof MODEL_SHAPE | typeof MODEL_DOCUMENT | typeof MODEL_CLUSTER;
+/**
+ * Mutable references
+ */
+export declare const DOCUMENT_MERGE = 30;
+export type DocumentType = typeof DOCUMENT_MERGE;
+/**
+ * External references
+ */
+export declare const EXTERNAL_PLUGIN_NODE = 40;
+export type ExternalType = typeof EXTERNAL_PLUGIN_NODE;
 export type KubunType = AttachmentType | ModelType | DocumentType | ExternalType;
 export declare class KubunID<T extends KubunType = KubunType> {
     #private;

package/lib/base.js

@@ -1 +1,61 @@
-var t,e,s,r;import{base36 as i}from"multiformats/bases/base36";import{concat as n,equals as o}from"./bytes.js";import{encodeVarint as a}from"./utils.js";export const NAMESPACE_CODE=181;let y=a(181);export var AttachmentType=((t={})[t.BINARY=1]="BINARY",t);export var ModelType=((e={})[e.SCALAR=10]="SCALAR",e[e.SHAPE=11]="SHAPE",e[e.DOCUMENT=20]="DOCUMENT",e[e.CLUSTER=21]="CLUSTER",e);export var DocumentType=((s={})[s.MERGE_DOCUMENT=30]="MERGE_DOCUMENT",s);export var ExternalType=((r={})[r.PLUGIN_NODE=40]="PLUGIN_NODE",r);export class KubunID{#t;#e;#s;#r;constructor(t,e){this.#t=t,this.#e=e}get type(){return this.#t}get data(){return this.#e}get bytes(){return null==this.#s&&(this.#s=this.toBytes()),this.#s}equals(t){return t instanceof KubunID&&t.type===this.type&&o(t.data,this.data)}toBytes(){return n([y,a(this.#t),this.#e])}toString(){return null==this.#r&&(this.#r=i.encode(this.bytes)),this.#r}[Symbol.for("nodejs.util.inspect.custom")](){return`KubunID(${this.toString()})`}}
+import { base36 } from 'multiformats/bases/base36';
+import { concat, equals } from './bytes.js';
+import { encodeVarint } from './utils.js';
+export const NAMESPACE_CODE = 0xb5;
+const NAMESPACE_BYTES = encodeVarint(NAMESPACE_CODE);
+/**
+ * Immutable references
+ */ export const ATTACHMENT_BINARY = 1;
+// DAG-only
+export const MODEL_SCALAR = 10;
+export const MODEL_SHAPE = 11;
+// Circular
+export const MODEL_DOCUMENT = 20;
+export const MODEL_CLUSTER = 21;
+/**
+ * Mutable references
+ */ export const DOCUMENT_MERGE = 30;
+/**
+ * External references
+ */ export const EXTERNAL_PLUGIN_NODE = 40;
+export class KubunID {
+    #type;
+    #dataBytes;
+    #idBytes;
+    #string;
+    constructor(type, dataBytes){
+        this.#type = type;
+        this.#dataBytes = dataBytes;
+    }
+    get type() {
+        return this.#type;
+    }
+    get data() {
+        return this.#dataBytes;
+    }
+    get bytes() {
+        if (this.#idBytes == null) {
+            this.#idBytes = this.toBytes();
+        }
+        return this.#idBytes;
+    }
+    equals(other) {
+        return other instanceof KubunID && other.type === this.type && equals(other.data, this.data);
+    }
+    toBytes() {
+        return concat([
+            NAMESPACE_BYTES,
+            encodeVarint(this.#type),
+            this.#dataBytes
+        ]);
+    }
+    toString() {
+        if (this.#string == null) {
+            this.#string = base36.encode(this.bytes);
+        }
+        return this.#string;
+    }
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        return `KubunID(${this.toString()})`;
+    }
+}

package/lib/bytes.d.ts

@@ -1,2 +1,2 @@
-export declare function concat(arrays: Uint8Array[], providedLength?: number): Uint8Array;
+export declare function concat(arrays: Array<Uint8Array>, providedLength?: number): Uint8Array;
 export declare function equals(a: Uint8Array, b: Uint8Array): boolean;

package/lib/bytes.js

@@ -1 +1,24 @@
-export function concat(e,t){let n=new Uint8Array(t??e.reduce((e,t)=>e+t.length,0)),r=0;for(let t of e)n.set(t,r),r+=t.length;return n}export function equals(e,t){if(e===t)return!0;if(e.byteLength!==t.byteLength)return!1;for(let n=0;n<e.byteLength;n++)if(e[n]!==t[n])return!1;return!0}
+export function concat(arrays, providedLength) {
+    const length = providedLength ?? arrays.reduce((acc, curr)=>acc + curr.length, 0);
+    const output = new Uint8Array(length);
+    let offset = 0;
+    for (const arr of arrays){
+        output.set(arr, offset);
+        offset += arr.length;
+    }
+    return output;
+}
+export function equals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    for(let i = 0; i < a.byteLength; i++){
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}

package/lib/cluster-model.d.ts

@@ -1,5 +1,5 @@
-import { KubunID, ModelType } from './base.js';
-export declare class ClusterModelID extends KubunID<ModelType.CLUSTER> {
+import { KubunID, MODEL_CLUSTER } from './base.js';
+export declare class ClusterModelID extends KubunID<typeof MODEL_CLUSTER> {
     static fromDigest(digestBytes: Uint8Array): ClusterModelID;
     static fromBytes(input: Uint8Array): ClusterModelID;
     static fromString(input: string): ClusterModelID;

package/lib/cluster-model.js

@@ -1 +1,26 @@
-import{base36 as r}from"multiformats/bases/base36";import{KubunID as t,ModelType as e,NAMESPACE_CODE as s}from"./base.js";import{decodeVarint as o}from"./utils.js";export class ClusterModelID extends t{static fromDigest(r){return new ClusterModelID(r)}static fromBytes(r){let[t,i]=o(r);if(t!==s)throw Error("Invalid KubunID: namespace mismatch");let[m,l]=o(r,i);if(m!==e.CLUSTER)throw Error("Invalid KubunID: type mismatch");return new ClusterModelID(r.slice(i+l))}static fromString(t){return ClusterModelID.fromBytes(r.decode(t))}constructor(r){super(e.CLUSTER,r)}}
+import { base36 } from 'multiformats/bases/base36';
+import { KubunID, MODEL_CLUSTER, NAMESPACE_CODE } from './base.js';
+import { decodeVarint } from './utils.js';
+export class ClusterModelID extends KubunID {
+    static fromDigest(digestBytes) {
+        return new ClusterModelID(digestBytes);
+    }
+    static fromBytes(input) {
+        const [namespace, namespaceLength] = decodeVarint(input);
+        if (namespace !== NAMESPACE_CODE) {
+            throw new Error('Invalid KubunID: namespace mismatch');
+        }
+        const [type, typeLength] = decodeVarint(input, namespaceLength);
+        if (type !== MODEL_CLUSTER) {
+            throw new Error('Invalid KubunID: type mismatch');
+        }
+        const digestBytes = input.slice(namespaceLength + typeLength);
+        return new ClusterModelID(digestBytes);
+    }
+    static fromString(input) {
+        return ClusterModelID.fromBytes(base36.decode(input));
+    }
+    constructor(digestBytes){
+        super(MODEL_CLUSTER, digestBytes);
+    }
+}

package/lib/decode.js

@@ -1 +1,34 @@
-import{base36 as r}from"multiformats/bases/base36";import{AttachmentID as e}from"./attachment.js";import{AttachmentType as t,DocumentType as o,ExternalType as m,ModelType as s,NAMESPACE_CODE as n}from"./base.js";import{ClusterModelID as f}from"./cluster-model.js";import{DocumentID as a}from"./document.js";import{DocumentModelID as u,ScalarModelID as i,ShapeModelID as c}from"./model.js";import{PluginNodeID as p}from"./plugin-node.js";import{decodeVarint as d}from"./utils.js";export function decodeID(l){let y="string"==typeof l?r.decode(l):l,[E,B]=d(y);if(E!==n)throw Error("Invalid KubunID: namespace mismatch");let[j]=d(y,B);switch(j){case t.BINARY:return e.fromBytes(y);case s.SCALAR:return i.fromBytes(y);case s.SHAPE:return c.fromBytes(y);case s.DOCUMENT:return u.fromBytes(y);case s.CLUSTER:return f.fromBytes(y);case o.MERGE_DOCUMENT:return a.fromBytes(y);case m.PLUGIN_NODE:return p.fromBytes(y);default:throw Error(`Invalid KubunID: unknown type ${j}`)}}
+import { base36 } from 'multiformats/bases/base36';
+import { AttachmentID } from './attachment.js';
+import { ATTACHMENT_BINARY, DOCUMENT_MERGE, EXTERNAL_PLUGIN_NODE, MODEL_CLUSTER, MODEL_DOCUMENT, MODEL_SCALAR, MODEL_SHAPE, NAMESPACE_CODE } from './base.js';
+import { ClusterModelID } from './cluster-model.js';
+import { DocumentID } from './document.js';
+import { DocumentModelID, ScalarModelID, ShapeModelID } from './model.js';
+import { PluginNodeID } from './plugin-node.js';
+import { decodeVarint } from './utils.js';
+export function decodeID(input) {
+    const bytes = typeof input === 'string' ? base36.decode(input) : input;
+    const [namespace, namespaceLength] = decodeVarint(bytes);
+    if (namespace !== NAMESPACE_CODE) {
+        throw new Error('Invalid KubunID: namespace mismatch');
+    }
+    const [type] = decodeVarint(bytes, namespaceLength);
+    switch(type){
+        case ATTACHMENT_BINARY:
+            return AttachmentID.fromBytes(bytes);
+        case MODEL_SCALAR:
+            return ScalarModelID.fromBytes(bytes);
+        case MODEL_SHAPE:
+            return ShapeModelID.fromBytes(bytes);
+        case MODEL_DOCUMENT:
+            return DocumentModelID.fromBytes(bytes);
+        case MODEL_CLUSTER:
+            return ClusterModelID.fromBytes(bytes);
+        case DOCUMENT_MERGE:
+            return DocumentID.fromBytes(bytes);
+        case EXTERNAL_PLUGIN_NODE:
+            return PluginNodeID.fromBytes(bytes);
+        default:
+            throw new Error(`Invalid KubunID: unknown type ${type}`);
+    }
+}

package/lib/document.d.ts

@@ -1,6 +1,6 @@
-import { DocumentType, KubunID } from './base.js';
+import { DOCUMENT_MERGE, KubunID } from './base.js';
 import { DocumentModelID } from './model.js';
-export declare class DocumentID extends KubunID<DocumentType.MERGE_DOCUMENT> {
+export declare class DocumentID extends KubunID<typeof DOCUMENT_MERGE> {
     #private;
     static create(model: DocumentModelID | Uint8Array | string, owner: string | Uint8Array, unique: Uint8Array): DocumentID;
     static fromBytes(input: Uint8Array): DocumentID;

package/lib/document.js

@@ -1 +1,81 @@
-import{fromUTF as t}from"@enkaku/codec";import{base36 as e}from"multiformats/bases/base36";import{DocumentType as r,KubunID as o,NAMESPACE_CODE as n}from"./base.js";import{concat as m}from"./bytes.js";import{DocumentModelID as i}from"./model.js";import{decodeVarint as s,digestBytes as c,encodeVarint as a}from"./utils.js";export class DocumentID extends o{static create(e,r,o){let n=m(["string"==typeof r?t(r):r,o]);return new DocumentID(i.from(e),c(n))}static fromBytes(t){let e=0,[o,m]=s(t);if(o!==n)throw Error("Invalid KubunID: namespace mismatch");let[c,a]=s(t,e+=m);if(c!==r.MERGE_DOCUMENT)throw Error("Invalid KubunID: type mismatch");let[u,f]=s(t,e+=a);e+=f;let l=t.slice(e,e+u),[D,d]=s(t,e+=u);e+=d;let p=new i(l,D),[I,h]=s(t,e);return e+=h,new DocumentID(p,t.slice(e,e+I))}static fromString(t){return DocumentID.fromBytes(e.decode(t))}static from(t){if(t instanceof DocumentID)return t;if(t instanceof Uint8Array)return DocumentID.fromBytes(t);if("string"==typeof t)return DocumentID.fromString(t);throw Error("Unsupported input type")}#t;#e;constructor(t,e){if(t.isLocal)throw Error("Invalid DocumentID: model cannot be local");let o=m([a(t.data.byteLength),t.data,a(t.index),a(e.byteLength),e]);super(r.MERGE_DOCUMENT,o),this.#t=t,this.#e=e}get model(){return this.#t}get content(){return this.#e}}
+import { fromUTF } from '@sozai/codec';
+import { base36 } from 'multiformats/bases/base36';
+import { DOCUMENT_MERGE, KubunID, NAMESPACE_CODE } from './base.js';
+import { concat } from './bytes.js';
+import { DocumentModelID } from './model.js';
+import { decodeVarint, digestBytes, encodeVarint } from './utils.js';
+export class DocumentID extends KubunID {
+    static create(model, owner, unique) {
+        const contentBytes = concat([
+            typeof owner === 'string' ? fromUTF(owner) : owner,
+            unique
+        ]);
+        return new DocumentID(DocumentModelID.from(model), digestBytes(contentBytes));
+    }
+    static fromBytes(input) {
+        let offset = 0;
+        // Check namespace = is it a KubunID?
+        const [namespace, namespaceLength] = decodeVarint(input);
+        if (namespace !== NAMESPACE_CODE) {
+            throw new Error('Invalid KubunID: namespace mismatch');
+        }
+        offset += namespaceLength;
+        // Check type matches
+        const [type, typeLength] = decodeVarint(input, offset);
+        if (type !== DOCUMENT_MERGE) {
+            throw new Error('Invalid KubunID: type mismatch');
+        }
+        offset += typeLength;
+        // Decode model ID: digest bytes followed by index
+        const [modelDataByteLength, modelDataVarintLength] = decodeVarint(input, offset);
+        offset += modelDataVarintLength;
+        const modelDigest = input.slice(offset, offset + modelDataByteLength);
+        offset += modelDataByteLength;
+        const [modelIndex, modelIndexVarintLength] = decodeVarint(input, offset);
+        offset += modelIndexVarintLength;
+        const modelID = new DocumentModelID(modelDigest, modelIndex);
+        // Extract content digest bytes
+        const [contentByteLength, contentVarintLength] = decodeVarint(input, offset);
+        offset += contentVarintLength;
+        const contentBytes = input.slice(offset, offset + contentByteLength);
+        return new DocumentID(modelID, contentBytes);
+    }
+    static fromString(input) {
+        return DocumentID.fromBytes(base36.decode(input));
+    }
+    static from(input) {
+        if (input instanceof DocumentID) {
+            return input;
+        }
+        if (input instanceof Uint8Array) {
+            return DocumentID.fromBytes(input);
+        }
+        if (typeof input === 'string') {
+            return DocumentID.fromString(input);
+        }
+        throw new Error('Unsupported input type');
+    }
+    #model;
+    #content;
+    constructor(model, contentDigestBytes){
+        if (model.isLocal) {
+            throw new Error('Invalid DocumentID: model cannot be local');
+        }
+        const data = concat([
+            encodeVarint(model.data.byteLength),
+            model.data,
+            encodeVarint(model.index),
+            encodeVarint(contentDigestBytes.byteLength),
+            contentDigestBytes
+        ]);
+        super(DOCUMENT_MERGE, data);
+        this.#model = model;
+        this.#content = contentDigestBytes;
+    }
+    get model() {
+        return this.#model;
+    }
+    get content() {
+        return this.#content;
+    }
+}

package/lib/index.js

@@ -1 +1,8 @@
-export{AttachmentID}from"./attachment.js";export{KubunID}from"./base.js";export{ClusterModelID}from"./cluster-model.js";export{decodeID}from"./decode.js";export{DocumentID}from"./document.js";export{DocumentModelID,ScalarModelID,ShapeModelID}from"./model.js";export{PluginNodeID}from"./plugin-node.js";export{digestBytes,digestJSON}from"./utils.js";
+export { AttachmentID } from './attachment.js';
+export { KubunID } from './base.js';
+export { ClusterModelID } from './cluster-model.js';
+export { decodeID } from './decode.js';
+export { DocumentID } from './document.js';
+export { DocumentModelID, ScalarModelID, ShapeModelID } from './model.js';
+export { PluginNodeID } from './plugin-node.js';
+export { digestBytes, digestJSON } from './utils.js';

package/lib/model.d.ts

@@ -1,17 +1,17 @@
-import { KubunID, ModelType } from './base.js';
-export declare class ScalarModelID extends KubunID<ModelType.SCALAR> {
+import { KubunID, MODEL_DOCUMENT, MODEL_SCALAR, MODEL_SHAPE } from './base.js';
+export declare class ScalarModelID extends KubunID<typeof MODEL_SCALAR> {
     static create(value: unknown): ScalarModelID;
     static fromBytes(input: Uint8Array): ScalarModelID;
     static fromString(input: string): ScalarModelID;
     constructor(digestBytes: Uint8Array);
 }
-export declare class ShapeModelID extends KubunID<ModelType.SHAPE> {
+export declare class ShapeModelID extends KubunID<typeof MODEL_SHAPE> {
     static create(value: unknown): ShapeModelID;
     static fromBytes(input: Uint8Array): ShapeModelID;
     static fromString(input: string): ShapeModelID;
     constructor(digestBytes: Uint8Array);
 }
-export declare class DocumentModelID extends KubunID<ModelType.DOCUMENT> {
+export declare class DocumentModelID extends KubunID<typeof MODEL_DOCUMENT> {
     #private;
     static fromBytes(input: Uint8Array): DocumentModelID;
     static fromString(input: string): DocumentModelID;

package/lib/model.js

@@ -1 +1,111 @@
-import{base36 as e}from"multiformats/bases/base36";import{KubunID as t,ModelType as r,NAMESPACE_CODE as o}from"./base.js";import{concat as n}from"./bytes.js";import{decodeVarint as s,digestJSON as i,encodeVarint as a}from"./utils.js";export class ScalarModelID extends t{static create(e){return new ScalarModelID(i(e))}static fromBytes(e){let[t,n]=s(e);if(t!==o)throw Error("Invalid KubunID: namespace mismatch");let[i,a]=s(e,n);if(i!==r.SCALAR)throw Error("Invalid KubunID: type mismatch");return new ScalarModelID(e.slice(n+a))}static fromString(t){return ScalarModelID.fromBytes(e.decode(t))}constructor(e){super(r.SCALAR,e)}}export class ShapeModelID extends t{static create(e){return new ShapeModelID(i(e))}static fromBytes(e){let[t,n]=s(e);if(t!==o)throw Error("Invalid KubunID: namespace mismatch");let[i,a]=s(e,n);if(i!==r.SHAPE)throw Error("Invalid KubunID: type mismatch");return new ShapeModelID(e.slice(n+a))}static fromString(t){return ShapeModelID.fromBytes(e.decode(t))}constructor(e){super(r.SHAPE,e)}}export class DocumentModelID extends t{static fromBytes(e){let[t,n]=s(e);if(t!==o)throw Error("Invalid KubunID: namespace mismatch");let[i,a]=s(e,n);if(i!==r.DOCUMENT)throw Error("Invalid KubunID: type mismatch");let c=e.slice(n+a,e.byteLength-1),[l]=s(e,e.byteLength-1);return new DocumentModelID(c,l)}static fromString(t){return DocumentModelID.fromBytes(e.decode(t))}static from(e){if(e instanceof DocumentModelID)return e;if(e instanceof Uint8Array)return DocumentModelID.fromBytes(e);if("string"==typeof e)return DocumentModelID.fromString(e);throw Error("Unsupported input type")}static local(e){return new DocumentModelID(new Uint8Array(0),e)}#e;#t;constructor(e,t){if(t>127)throw RangeError(`Index ${t} exceeds maximum of 127`);super(r.DOCUMENT,e),this.#e=t,this.#t=0===e.length}get index(){return this.#e}get isLocal(){return this.#t}toBytes(){return n([super.toBytes(),a(this.#e)])}toGlobal(e){let t=e instanceof DocumentModelID?e.data:e;return new DocumentModelID(t,this.#e)}}
+import { base36 } from 'multiformats/bases/base36';
+import { KubunID, MODEL_DOCUMENT, MODEL_SCALAR, MODEL_SHAPE, NAMESPACE_CODE } from './base.js';
+import { concat } from './bytes.js';
+import { decodeVarint, digestJSON, encodeVarint } from './utils.js';
+export class ScalarModelID extends KubunID {
+    static create(value) {
+        return new ScalarModelID(digestJSON(value));
+    }
+    static fromBytes(input) {
+        const [namespace, namespaceLength] = decodeVarint(input);
+        if (namespace !== NAMESPACE_CODE) {
+            throw new Error('Invalid KubunID: namespace mismatch');
+        }
+        const [type, typeLength] = decodeVarint(input, namespaceLength);
+        if (type !== MODEL_SCALAR) {
+            throw new Error('Invalid KubunID: type mismatch');
+        }
+        const digestBytes = input.slice(namespaceLength + typeLength);
+        return new ScalarModelID(digestBytes);
+    }
+    static fromString(input) {
+        return ScalarModelID.fromBytes(base36.decode(input));
+    }
+    constructor(digestBytes){
+        super(MODEL_SCALAR, digestBytes);
+    }
+}
+export class ShapeModelID extends KubunID {
+    static create(value) {
+        return new ShapeModelID(digestJSON(value));
+    }
+    static fromBytes(input) {
+        const [namespace, namespaceLength] = decodeVarint(input);
+        if (namespace !== NAMESPACE_CODE) {
+            throw new Error('Invalid KubunID: namespace mismatch');
+        }
+        const [type, typeLength] = decodeVarint(input, namespaceLength);
+        if (type !== MODEL_SHAPE) {
+            throw new Error('Invalid KubunID: type mismatch');
+        }
+        const digestBytes = input.slice(namespaceLength + typeLength);
+        return new ShapeModelID(digestBytes);
+    }
+    static fromString(input) {
+        return ShapeModelID.fromBytes(base36.decode(input));
+    }
+    constructor(digestBytes){
+        super(MODEL_SHAPE, digestBytes);
+    }
+}
+const MAX_INDEX = 127;
+export class DocumentModelID extends KubunID {
+    static fromBytes(input) {
+        const [namespace, namespaceLength] = decodeVarint(input);
+        if (namespace !== NAMESPACE_CODE) {
+            throw new Error('Invalid KubunID: namespace mismatch');
+        }
+        const [type, typeLength] = decodeVarint(input, namespaceLength);
+        if (type !== MODEL_DOCUMENT) {
+            throw new Error('Invalid KubunID: type mismatch');
+        }
+        const digestBytes = input.slice(namespaceLength + typeLength, input.byteLength - 1);
+        const [index] = decodeVarint(input, input.byteLength - 1);
+        return new DocumentModelID(digestBytes, index);
+    }
+    static fromString(input) {
+        return DocumentModelID.fromBytes(base36.decode(input));
+    }
+    static from(input) {
+        if (input instanceof DocumentModelID) {
+            return input;
+        }
+        if (input instanceof Uint8Array) {
+            return DocumentModelID.fromBytes(input);
+        }
+        if (typeof input === 'string') {
+            return DocumentModelID.fromString(input);
+        }
+        throw new Error('Unsupported input type');
+    }
+    static local(index) {
+        return new DocumentModelID(new Uint8Array(0), index);
+    }
+    #index;
+    #isLocal;
+    constructor(digestBytes, index){
+        if (index > MAX_INDEX) {
+            // index should be encoded in a single byte
+            throw new RangeError(`Index ${index} exceeds maximum of ${MAX_INDEX}`);
+        }
+        super(MODEL_DOCUMENT, digestBytes);
+        this.#index = index;
+        this.#isLocal = digestBytes.length === 0;
+    }
+    get index() {
+        return this.#index;
+    }
+    get isLocal() {
+        return this.#isLocal;
+    }
+    toBytes() {
+        return concat([
+            super.toBytes(),
+            encodeVarint(this.#index)
+        ]);
+    }
+    toGlobal(digestBytesOrModelID) {
+        const digestBytes = digestBytesOrModelID instanceof DocumentModelID ? digestBytesOrModelID.data : digestBytesOrModelID;
+        return new DocumentModelID(digestBytes, this.#index);
+    }
+}

package/lib/plugin-node.d.ts

@@ -1,5 +1,5 @@
-import { ExternalType, KubunID } from './base.js';
-export declare class PluginNodeID extends KubunID<ExternalType.PLUGIN_NODE> {
+import { EXTERNAL_PLUGIN_NODE, KubunID } from './base.js';
+export declare class PluginNodeID extends KubunID<typeof EXTERNAL_PLUGIN_NODE> {
     #private;
     static create(plugin: string, typeName: string, localID: string): PluginNodeID;
     static fromBytes(input: Uint8Array): PluginNodeID;

package/lib/plugin-node.js

@@ -1 +1,84 @@
-import{fromUTF as t,toUTF as e}from"@enkaku/codec";import{base36 as r}from"multiformats/bases/base36";import{ExternalType as i,KubunID as n,NAMESPACE_CODE as o}from"./base.js";import{concat as s}from"./bytes.js";import{decodeVarint as l,encodeVarint as u}from"./utils.js";export class PluginNodeID extends n{static create(t,e,r){return new PluginNodeID(t,e,r)}static fromBytes(t){let r=0,[n,s]=l(t);if(n!==o)throw Error("Invalid KubunID: namespace mismatch");let[u,a]=l(t,r+=s);if(u!==i.PLUGIN_NODE)throw Error("Invalid KubunID: type mismatch");let[m,c]=l(t,r+=a);r+=c;let p=0===m?"":e(t.slice(r,r+m)),[f,g]=l(t,r+=m);r+=g;let I=0===f?"":e(t.slice(r,r+f)),[y,D]=l(t,r+=f);return r+=D,new PluginNodeID(p,I,0===y?"":e(t.slice(r,r+y)))}static fromString(t){return PluginNodeID.fromBytes(r.decode(t))}static from(t){if(t instanceof PluginNodeID)return t;if(t instanceof Uint8Array)return PluginNodeID.fromBytes(t);if("string"==typeof t)return PluginNodeID.fromString(t);throw Error("Unsupported input type")}#t;#e;#r;constructor(e,r,n){let o=t(e),l=t(r),a=t(n),m=s([u(o.byteLength),o,u(l.byteLength),l,u(a.byteLength),a]);super(i.PLUGIN_NODE,m),this.#t=e,this.#e=r,this.#r=n}get plugin(){return this.#t}get typeName(){return this.#e}get localID(){return this.#r}}
+import { fromUTF, toUTF } from '@sozai/codec';
+import { base36 } from 'multiformats/bases/base36';
+import { EXTERNAL_PLUGIN_NODE, KubunID, NAMESPACE_CODE } from './base.js';
+import { concat } from './bytes.js';
+import { decodeVarint, encodeVarint } from './utils.js';
+export class PluginNodeID extends KubunID {
+    static create(plugin, typeName, localID) {
+        return new PluginNodeID(plugin, typeName, localID);
+    }
+    static fromBytes(input) {
+        let offset = 0;
+        // Check namespace
+        const [namespace, namespaceLength] = decodeVarint(input);
+        if (namespace !== NAMESPACE_CODE) {
+            throw new Error('Invalid KubunID: namespace mismatch');
+        }
+        offset += namespaceLength;
+        // Check type matches
+        const [type, typeLength] = decodeVarint(input, offset);
+        if (type !== EXTERNAL_PLUGIN_NODE) {
+            throw new Error('Invalid KubunID: type mismatch');
+        }
+        offset += typeLength;
+        // Decode plugin
+        const [pluginLength, pluginVarintLength] = decodeVarint(input, offset);
+        offset += pluginVarintLength;
+        const plugin = pluginLength === 0 ? '' : toUTF(input.slice(offset, offset + pluginLength));
+        offset += pluginLength;
+        // Decode typeName
+        const [typeNameLength, typeNameVarintLength] = decodeVarint(input, offset);
+        offset += typeNameVarintLength;
+        const typeName = typeNameLength === 0 ? '' : toUTF(input.slice(offset, offset + typeNameLength));
+        offset += typeNameLength;
+        // Decode localID
+        const [localIDLength, localIDVarintLength] = decodeVarint(input, offset);
+        offset += localIDVarintLength;
+        const localID = localIDLength === 0 ? '' : toUTF(input.slice(offset, offset + localIDLength));
+        return new PluginNodeID(plugin, typeName, localID);
+    }
+    static fromString(input) {
+        return PluginNodeID.fromBytes(base36.decode(input));
+    }
+    static from(input) {
+        if (input instanceof PluginNodeID) {
+            return input;
+        }
+        if (input instanceof Uint8Array) {
+            return PluginNodeID.fromBytes(input);
+        }
+        if (typeof input === 'string') {
+            return PluginNodeID.fromString(input);
+        }
+        throw new Error('Unsupported input type');
+    }
+    #plugin;
+    #typeName;
+    #localID;
+    constructor(plugin, typeName, localID){
+        const pluginBytes = fromUTF(plugin);
+        const typeNameBytes = fromUTF(typeName);
+        const localIDBytes = fromUTF(localID);
+        const data = concat([
+            encodeVarint(pluginBytes.byteLength),
+            pluginBytes,
+            encodeVarint(typeNameBytes.byteLength),
+            typeNameBytes,
+            encodeVarint(localIDBytes.byteLength),
+            localIDBytes
+        ]);
+        super(EXTERNAL_PLUGIN_NODE, data);
+        this.#plugin = plugin;
+        this.#typeName = typeName;
+        this.#localID = localID;
+    }
+    get plugin() {
+        return this.#plugin;
+    }
+    get typeName() {
+        return this.#typeName;
+    }
+    get localID() {
+        return this.#localID;
+    }
+}

package/lib/utils.js

@@ -1 +1,19 @@
-import{canonicalStringify as e,fromUTF as t}from"@enkaku/codec";import{blake3 as n}from"@noble/hashes/blake3.js";import r from"varint";export function digestBytes(e){return n(e)}export function digestJSON(n){return digestBytes(t(e(n)))}export function decodeVarint(e,t){return[r.decode(e,t),r.decode.bytes??0]}export function encodeVarint(e){return r.encode(e,new Uint8Array(r.encodingLength(e)))}
+import { blake3 } from '@noble/hashes/blake3.js';
+import { canonicalStringify, fromUTF } from '@sozai/codec';
+import varint from 'varint';
+export function digestBytes(bytes) {
+    return blake3(bytes);
+}
+export function digestJSON(value) {
+    return digestBytes(fromUTF(canonicalStringify(value)));
+}
+export function decodeVarint(bytes, offset) {
+    const value = varint.decode(bytes, offset);
+    return [
+        value,
+        varint.decode.bytes ?? 0
+    ];
+}
+export function encodeVarint(value) {
+    return varint.encode(value, new Uint8Array(varint.encodingLength(value)));
+}

package/package.json

@@ -1,36 +1,36 @@
 {
   "name": "@kubun/id",
-  "version": "0.10.0",
-  "license": "see LICENSE.md",
+  "version": "0.12.0",
   "keywords": [],
+  "license": "see LICENSE.md",
+  "sideEffects": false,
   "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
   "exports": {
     ".": "./lib/index.js"
   },
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "files": [
     "lib/*",
     "LICENSE.md"
   ],
-  "sideEffects": false,
   "dependencies": {
-    "@enkaku/codec": "^0.16.0",
     "@noble/hashes": "^2.2.0",
-    "multiformats": "^14.0.0",
+    "@sozai/codec": "^0.4.0",
+    "multiformats": "^14.0.5",
     "varint": "^6.0.0"
   },
   "devDependencies": {
     "@types/varint": "^6.0.3"
   },
   "scripts": {
+    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
     "build:clean": "del lib",
-    "build:js": "swc src -d ./lib --config-file ../../swc.json --strip-leading-paths",
+    "build:js": "swc src -d ./lib --config-file ../../node_modules/@kigu/dev/swc.json --strip-leading-paths",
     "build:types": "tsc --emitDeclarationOnly --skipLibCheck",
     "build:types:ci": "tsc --emitDeclarationOnly --declarationMap false",
-    "build": "pnpm run build:clean && pnpm run build:js && pnpm run build:types",
+    "test": "pnpm run test:types && pnpm run test:unit",
     "test:types": "tsc --noEmit",
-    "test:unit": "vitest run",
-    "test": "pnpm run test:types && pnpm run test:unit"
+    "test:unit": "vitest run"
   }
 }