diff --git a/types/ndn-js/blob.d.ts b/types/ndn-js/blob.d.ts new file mode 100644 index 0000000000..9b3d56bb67 --- /dev/null +++ b/types/ndn-js/blob.d.ts @@ -0,0 +1,20 @@ +export class Blob { + constructor(value?: Blob); + constructor(value: Buffer, copy?: boolean); + constructor(value: ReadonlyArray|string); + + buf(): Buffer; + equals(other: Blob): boolean; + isNull(): boolean; + size(): number; +} + +export class SignedBlob extends Blob { + constructor(); + constructor(value: Blob|Buffer|ReadonlyArray, signedPortionBeginOffset: number, signedPortionEndOffset: number); + + getSignedPortionBeginOffset(): number; + getSignedPortionEndOffset(): number; + signedBuf(): Buffer; + signedSize(): number; +} diff --git a/types/ndn-js/data.d.ts b/types/ndn-js/data.d.ts new file mode 100644 index 0000000000..9d6c03cda1 --- /dev/null +++ b/types/ndn-js/data.d.ts @@ -0,0 +1,46 @@ +import { Blob } from "./blob"; +import { Name } from "./name"; +import { Signature } from "./signature"; + +export class Data { + constructor(name?: Name|string); + constructor(data: Data); + + getName(): Name; + getFullName(): Name; + getMetaInfo(): MetaInfo; + getContent(): Blob; + getSignature(): Signature; + getCongestionMark(): number; + getIncomingFaceId(): number; + + setName(name: Name): Data; + setMetaInfo(meta: MetaInfo): Data; + setContent(content: Blob|Buffer): Data; + setSignature(sig: Signature): Data; + + wireDecode(input: Blob|Buffer): void; + wireEncode(): Blob; +} + +export enum ContentType { + BLOB = 0, + LINK = 1, + KEY = 2, + NACK = 3, + OTHER_CODE = 0x7fff, +} + +export class MetaInfo { + constructor(meta?: MetaInfo); + + getType(): ContentType; + getOtherTypeCode(): number; + getFreshnessPeriod(): number; + getFinalBlockId(): Name.Component; + + setType(type: ContentType): void; + setOtherTypeCode(otherTypeCode: number): void; + setFreshnessPeriod(freshness: number): void; + setFinalBlockId(comp: Name.Component): void; +} diff --git a/types/ndn-js/face.d.ts b/types/ndn-js/face.d.ts new file mode 100644 index 0000000000..09a8a84981 --- /dev/null +++ b/types/ndn-js/face.d.ts @@ -0,0 +1,62 @@ +import { Blob } from "./blob"; +import { Data } from "./data"; +import { Interest } from "./interest"; +import { KeyChain } from "./key-chain"; +import { Name } from "./name"; +import { NetworkNack } from "./network-nack"; +import { Transport, TransportConnectionInfo } from "./transport"; + +export interface FaceCtorOptions { + getTransport?: () => Transport; + getConnectionInfo?: () => TransportConnectionInfo; + connectionInfo?: TransportConnectionInfo|null; + host?: string|null; + port?: number|null; +} + +export type OnInterestCallback = (prefix: Name, interest: Interest, face: Face, filterId: number, filter: InterestFilter) => any; + +export class Face { + constructor(transport: Transport, connectionInfo: TransportConnectionInfo); + constructor(settings?: FaceCtorOptions); + + expressInterest(interest: Interest|Name, + onData: (interest: Interest, data: Data) => any, + onTimeout?: (interest: Interest) => any, + onNetworkNack?: (interest: Interest, nack: NetworkNack) => any): number; + expressInterest(name: Name, + interestTemplate: Interest, + onData: (interest: Interest, data: Data) => any, + onTimeout?: (interest: Interest) => any, + onNetworkNack?: (interest: Interest, nack: NetworkNack) => any): number; + + static getMaxNdnPacketSize(): number; + putData(data: Data): void; + + registerPrefix(prefix: Name, + onInterest: OnInterestCallback, + onRegisterFailed: (prefix: Name) => any, + onRegisterSuccess?: (prefix: Name, registeredPrefixId: number) => any, + flags?: ForwardingFlags): number; + + removePendingInterest(id: number): void; + removeRegisteredPrefix(id: number): void; + send(encoding: Blob|Buffer): void; + setCommandCertificateName(certificateName: Name): void; + setCommandSigningInfo(keyChain: KeyChain, certificateName: Name): void; + setInterestFilter(filter: InterestFilter|Name, onInterest: OnInterestCallback): number; + unsetInterestFilter(id: number): void; +} + +// no declaration because this type is rarely used +export class ForwardingFlags {} + +export class InterestFilter { + constructor(filter: InterestFilter); + constructor(prefix: Name|string, regexFilter?: string); + + doesMatch(name: Name): boolean; + getPrefix(): Name; + getRegexFilter(): string; + hasRegexFilter(): boolean; +} diff --git a/types/ndn-js/index.d.ts b/types/ndn-js/index.d.ts new file mode 100644 index 0000000000..0e584e9297 --- /dev/null +++ b/types/ndn-js/index.d.ts @@ -0,0 +1,16 @@ +// Type definitions for ndn-js 0.18 +// Project: https://github.com/named-data/ndn-js +// Definitions by: Junxiao +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped + +export as namespace ndn; +export * from "./blob"; +export * from "./data"; +export * from "./face"; +export * from "./interest"; +export * from "./key-chain"; +export * from "./memory-content-cache"; +export * from "./name"; +export * from "./network-nack"; +export * from "./signature"; +export * from "./transport"; diff --git a/types/ndn-js/interest.d.ts b/types/ndn-js/interest.d.ts new file mode 100644 index 0000000000..20dd23c9a0 --- /dev/null +++ b/types/ndn-js/interest.d.ts @@ -0,0 +1,49 @@ +import { Blob } from "./blob"; +import { Data } from "./data"; +import { Name } from "./name"; + +export class Interest { + constructor(name?: Name|string); + constructor(interest: Interest); + + getName(): Name; + getCanBePrefix(): boolean; + getMustBeFresh(): boolean; + getForwardingHint(): DelegationSet; + getNonce(): Blob; + getInterestLifetimeMilliseconds(): number; + getApplicationParameters(): Blob; + getIncomingFaceId(): number; + + setName(name: Name): Interest; + setCanBePrefix(canBePrefix: boolean): Interest; + setMustBeFresh(mustBeFresh: boolean): Interest; + setForwardingHint(fh: DelegationSet): Interest; + setInterestLifetimeMilliseconds(lifetime: number): Interest; + setApplicationParameters(parameters: Blob|Buffer): Interest; + + appendParametersDigestToName(): Interest; + matchesData(data: Data): boolean; + matchesName(name: Name): boolean; + refreshNonce(): void; + toUri(): string; + wireDecode(input: Blob|Buffer): void; + wireEncode(): Blob; +} + +export class DelegationSet { + size(): number; + get(i: number): DelegationSet.Delegation; + find(name: Name): number; + + add(preference: number, name: Name): void; + remove(name: Name): boolean; + clear(): void; +} + +export namespace DelegationSet { + class Delegation { + getPreference(): number; + getName(): Name; + } +} diff --git a/types/ndn-js/key-chain.d.ts b/types/ndn-js/key-chain.d.ts new file mode 100644 index 0000000000..f2ad3612a5 --- /dev/null +++ b/types/ndn-js/key-chain.d.ts @@ -0,0 +1,58 @@ +import { Data } from "./data"; +import { Interest } from "./interest"; +import { Name } from "./name"; + +export class KeyChain { + constructor(); + constructor(pibLocator: string, tpmLocator: string, allowReset?: boolean); + + static getDefaultKeyParams(): KeyParams; + getPib(): Pib; + getTpm(): Tpm; + + createIdentityV2(identityName: Name, params?: KeyParams): PibIdentity; + createIdentityV2(identityName: Name, onComplete: (identity: PibIdentity) => any, onError?: (err: any) => any): void; + createIdentityV2(identityName: Name, params: KeyParams, onComplete: (identity: PibIdentity) => any, onError?: (err: any) => any): void; + deleteIdentity(identity: PibIdentity, onComplete?: () => any, onError?: (err: any) => any): void; + setDefaultIdentity(identity: PibIdentity, onComplete?: () => any, onError?: (err: any) => any): void; + + createKey(identity: PibIdentity, params?: KeyParams): PibKey; + createKey(identity: PibIdentity, onComplete: (key: PibKey) => any, onError?: (err: any) => any): void; + createKey(identity: PibIdentity, params: KeyParams, onComplete: (key: PibKey) => any, onError?: (err: any) => any): void; + deleteKey(identity: PibIdentity, key: PibKey, onComplete?: () => any, onError?: (err: any) => any): void; + setDefaultKey(identity: PibIdentity, key: PibKey, onComplete?: () => any, onError?: (err: any) => any): void; + + addCertificate(key: PibKey, certificate: CertificateV2, onComplete?: () => any, onError?: (err: any) => any): void; + deleteCertificate(key: PibKey, certificateName: Name, onComplete?: () => any, onError?: (err: any) => any): void; + setDefaultCertificate(key: PibKey, certificate: CertificateV2, onComplete?: () => any, onError?: (err: any) => any): void; + + sign(interest: Interest, params: SigningInfo, onComplete?: (interest: Interest) => any, onError?: (err: any) => any): void; + sign(data: Data, params: SigningInfo, onComplete?: (data: Data) => any, onError?: (err: any) => any): void; + signWithSha256(packet: Data|Interest): void; +} + +// no declaration because these types are rarely used +export class Pib {} +export class PibIdentity {} +export class PibKey {} +export class KeyParams {} +export class CertificateV2 {} +export class Tpm {} + +export class SigningInfo { + constructor(signerType: SigningInfo.SignerType, signerName: Name); + constructor(arg?: SigningInfo|PibIdentity|PibKey|string); + + getSignerType(): SigningInfo.SignerType; + getSignerName(): Name; +} + +export namespace SigningInfo { + enum SignerType { + NULL = 0, + ID = 1, + KEY = 2, + CERT = 3, + SHA256 = 4, + } +} diff --git a/types/ndn-js/memory-content-cache.d.ts b/types/ndn-js/memory-content-cache.d.ts new file mode 100644 index 0000000000..75c47419c0 --- /dev/null +++ b/types/ndn-js/memory-content-cache.d.ts @@ -0,0 +1,19 @@ +import { Data } from "./data"; +import { Face, ForwardingFlags, InterestFilter, OnInterestCallback } from "./face"; +import { Interest } from "./interest"; +import { Name } from "./name"; + +export class MemoryContentCache { + constructor(face: Face, cleanupIntervalMilliseconds?: number); + + add(data: Data): void; + getMinimumCacheLifetime(): number; + getStorePendingInterest(): OnInterestCallback; + registerPrefix(name: Name, onRegisterFailed: (prefix: Name) => any, + onRegisterSuccess?: (prefix: Name, registeredPrefixId: number) => any, + onDataNotFound?: OnInterestCallback, flags?: ForwardingFlags): void; + setInterestFilter(filter: InterestFilter|Name, onDataNotFound?: OnInterestCallback): void; + setMinimumCacheLifetime(minimumCacheLifetime: number): void; + storePendingInterest(interest: Interest, face: Face): void; + unregisterAll(): void; +} diff --git a/types/ndn-js/name.d.ts b/types/ndn-js/name.d.ts new file mode 100644 index 0000000000..9b4d38733d --- /dev/null +++ b/types/ndn-js/name.d.ts @@ -0,0 +1,87 @@ +import { Blob } from "./blob"; + +export enum ComponentType { + IMPLICIT_SHA256_DIGEST = 1, + PARAMETERS_SHA256_DIGEST = 2, + GENERIC = 8, + OTHER_CODE = 0x7fff, +} + +export type CompareResult = -1|0|1; + +export namespace Name { + class Component { + constructor(value?: ReadonlyArray|ArrayBuffer|Uint8Array|string|Blob, type?: ComponentType, otherTypeCode?: number); + constructor(component: Component); + + compare(other: Component): CompareResult; + equals(other: Component): boolean; + static fromImplicitSha256Digest(digest: Blob): Component; + static fromParametersSha256Digest(digest: Blob): Component; + getOtherTypeCode(): number; + getSuccessor(): Component; + getType(): ComponentType; + getValue(): Blob; + isGeneric(): boolean; + isImplicitSha256Digest(): boolean; + isParametersSha256Digest(): boolean; + toEscapedString(): string; + + static fromNumber(number: number, type?: ComponentType, otherTypeCode?: number): Component; + static fromNumberWithMarker(number: number, marker: number): Component; + static fromSegment(segment: number): Component; + static fromSegmentOffset(segmentOffset: number): Component; + static fromSequenceNumber(sequenceNumber: number): Component; + static fromTimestamp(timestamp: number): Component; + static fromVersion(version: number): Component; + + isSegment(): boolean; + isSegmentOffset(): boolean; + isSequenceNumber(): boolean; + isTimestamp(): boolean; + isVersion(): boolean; + + toNumber(): number; + toNumberWithMarker(marker: number): number; + toSegment(): number; + toSegmentOffset(): number; + toSequenceNumber(): number; + toTimestamp(): number; + toVersion(): number; + } +} + +export class Name { + constructor(components?: ReadonlyArray); + constructor(name: Name|string); + + append(value: ReadonlyArray|ArrayBuffer|Uint8Array|string|Blob, type?: ComponentType, otherTypeCode?: number): Name; + append(components: Name.Component|Name): Name; + appendImplicitSha256Digest(digest: Blob): Name; + appendParametersSha256Digest(digest: Blob): Name; + appendSegment(segment: number): Name; + appendSegmentOffset(segmentOffset: number): Name; + appendSequenceNumber(sequenceNumber: number): Name; + appendTimestamp(timestamp: number): Name; + appendVersion(version: number): Name; + + clear(): void; + + compare(other: Name): CompareResult; + compare(iStartComponent: number, nComponents: number, other: Name, + iOtherStartComponent?: number, nOtherComponents?: number): CompareResult; + + equals(other: Name): boolean; + static fromEscapedString(uri: string): Name; + get(i: number): Name.Component; + getPrefix(nComponents: number): Name; + getSubName(iStartComponent: number, nComponents?: number): Name; + getSuccessor(): Name; + match(name: Name): boolean; + set(uri: string): void; + size(): number; + toUri(includeScheme?: boolean): string; + + wireDecode(input: Blob|Buffer): void; + wireEncode(): Blob; +} diff --git a/types/ndn-js/network-nack.d.ts b/types/ndn-js/network-nack.d.ts new file mode 100644 index 0000000000..6ffb681313 --- /dev/null +++ b/types/ndn-js/network-nack.d.ts @@ -0,0 +1,14 @@ +export namespace NetworkNack { + enum Reason { + NONE = 0, + CONGESTION = 50, + DUPLICATE = 100, + NO_ROUTE = 150, + OTHER_CODE = 0x7fff, + } +} + +export class NetworkNack { + getOtherReasonCode(): number; + getReason(): NetworkNack.Reason; +} diff --git a/types/ndn-js/signature.d.ts b/types/ndn-js/signature.d.ts new file mode 100644 index 0000000000..0f9eed260f --- /dev/null +++ b/types/ndn-js/signature.d.ts @@ -0,0 +1,74 @@ +import { Blob } from "./blob"; +import { Name } from "./name"; + +export enum KeyLocatorType { + KEYNAME = 1, + KEY_LOCATOR_DIGEST = 2, +} + +export class KeyLocator { + constructor(kl?: KeyLocator); + + getType(): KeyLocatorType; + getKeyName(): Name; + getKeyData(): Blob; + + setType(type: KeyLocatorType): void; + setKeyName(name: Name): void; + setKeyData(keyData: Blob): void; + + clear(): void; +} + +export class ValidityPeriod { + constructor(validity?: ValidityPeriod); + constructor(notBefore: number, notAfter: number); + + hasPeriod(): boolean; + getNotBefore(): number; + getNotAfter(): number; + isValid(time?: number): boolean; + + equals(other: ValidityPeriod): boolean; + clear(): void; +} + +export abstract class Signature { + clone(): Signature; +} + +export class SignatureBase extends Signature { + constructor(); + getSignature(): Blob; + setSignature(sigValue: Blob): void; + clone(): T; +} + +export class SignatureBaseKl extends SignatureBase { + getKeyLocator(): KeyLocator; + setKeyLocator(kl?: KeyLocator): void; +} + +export class SignatureBaseKlVp extends SignatureBaseKl { + getValidityPeriod(): ValidityPeriod; + setValidityPeriod(validity?: ValidityPeriod): void; +} + +export class GenericSignature extends SignatureBase { + constructor(); + getTypeCode(): number; + getSignatureInfoEncoding(): Blob; + setSignatureInfoEncoding(encoding: Blob, typeCode?: number): void; +} + +export class DigestSha256Signature extends SignatureBase { +} + +export class Sha256WithRsaSignature extends SignatureBaseKlVp { +} + +export class Sha256WithEcdsaSignature extends SignatureBaseKlVp { +} + +export class HmacWithSha25Signature extends SignatureBaseKl { +} diff --git a/types/ndn-js/test/blob.ts b/types/ndn-js/test/blob.ts new file mode 100644 index 0000000000..b5540b831b --- /dev/null +++ b/types/ndn-js/test/blob.ts @@ -0,0 +1,20 @@ +/// +import ndn = require("ndn-js"); + +let blob = new ndn.Blob(); +blob = new ndn.Blob(blob); +blob = new ndn.Blob(Buffer.alloc(4)); +blob = new ndn.Blob([0x08, 0x01, 0x41]); +blob = new ndn.Blob("str"); + +let buf: Buffer = blob.buf(); +let b: boolean = blob.equals(blob); +b = blob.isNull(); +let n: number = blob.size(); + +let sb = new ndn.SignedBlob(); +sb = new ndn.SignedBlob(blob, 20, 40); +n = sb.getSignedPortionBeginOffset(); +n = sb.getSignedPortionEndOffset(); +buf = sb.signedBuf(); +n = sb.signedSize(); diff --git a/types/ndn-js/test/data.ts b/types/ndn-js/test/data.ts new file mode 100644 index 0000000000..367a7a0ec7 --- /dev/null +++ b/types/ndn-js/test/data.ts @@ -0,0 +1,37 @@ +/// +import ndn = require("ndn-js"); + +let meta = new ndn.MetaInfo(); +meta = new ndn.MetaInfo(meta); +const ct: ndn.ContentType = meta.getType(); +let n: number = meta.getOtherTypeCode(); +n = meta.getFreshnessPeriod(); +const comp: ndn.Name.Component = meta.getFinalBlockId(); + +meta.setType(ndn.ContentType.OTHER_CODE); +meta.setOtherTypeCode(1000); +meta.setFreshnessPeriod(5000); +meta.setFinalBlockId(comp); + +let data = new ndn.Data(); +data = new ndn.Data(new ndn.Name("/A")); +data = new ndn.Data("/A"); +data = new ndn.Data(data); + +let name: ndn.Name = data.getName(); +name = data.getFullName(); +meta = data.getMetaInfo(); +let blob: ndn.Blob = data.getContent(); +const sig: ndn.Signature = data.getSignature(); +n = data.getCongestionMark(); +n = data.getIncomingFaceId(); + +data = data.setName(name) + .setMetaInfo(meta) + .setContent(blob) + .setContent(Buffer.alloc(4)) + .setSignature(sig); + +data.wireDecode(blob); +data.wireDecode(Buffer.alloc(4)); +blob = data.wireEncode(); diff --git a/types/ndn-js/test/face.ts b/types/ndn-js/test/face.ts new file mode 100644 index 0000000000..90ba176d27 --- /dev/null +++ b/types/ndn-js/test/face.ts @@ -0,0 +1,47 @@ +import ndn = require("ndn-js"); + +let filter = new ndn.InterestFilter("/A"); +filter = new ndn.InterestFilter(new ndn.Name("/A"), "<>{2}"); +filter = new ndn.InterestFilter(filter); + +let b: boolean = filter.doesMatch(new ndn.Name("/B")); +const name: ndn.Name = filter.getPrefix(); +const s: string = filter.getRegexFilter(); +b = filter.hasRegexFilter(); + +const face = new ndn.Face(); + +let n: number = face.expressInterest(new ndn.Interest(), + (interest: ndn.Interest, data: ndn.Data) => {}); +face.expressInterest(new ndn.Name("/A"), + (interest: ndn.Interest, data: ndn.Data) => {}, + (interest: ndn.Interest) => {}); +face.expressInterest(new ndn.Name("/A"), + new ndn.Interest().setCanBePrefix(true), + (interest: ndn.Interest, data: ndn.Data) => {}, + (interest: ndn.Interest) => {}, + (interest: ndn.Interest, nack: ndn.NetworkNack) => {}); + +n = ndn.Face.getMaxNdnPacketSize(); +face.putData(new ndn.Data()); + +n = face.registerPrefix(new ndn.Name("/A"), + (prefix: ndn.Name, interest: ndn.Interest) => {}, + (prefix: ndn.Name) => {}); +face.registerPrefix(new ndn.Name("/A"), + (prefix: ndn.Name, interest: ndn.Interest) => {}, + (prefix: ndn.Name) => {}, + (prefix: ndn.Name, id: number) => {}); + +face.removePendingInterest(n); +face.removeRegisteredPrefix(n); +face.send(new ndn.Blob()); +face.setCommandCertificateName(name); +face.setCommandSigningInfo(new ndn.KeyChain(), name); + +n = face.setInterestFilter(filter, + (prefix: ndn.Name, interest: ndn.Interest, face: ndn.Face, filterId: number, filter: ndn.InterestFilter) => {}); +face.setInterestFilter(name, + (prefix: ndn.Name, interest: ndn.Interest) => {}); + +face.unsetInterestFilter(n); diff --git a/types/ndn-js/test/interest.ts b/types/ndn-js/test/interest.ts new file mode 100644 index 0000000000..008a795aec --- /dev/null +++ b/types/ndn-js/test/interest.ts @@ -0,0 +1,40 @@ +/// +import ndn = require("ndn-js"); + +let interest = new ndn.Interest(); +interest = new ndn.Interest(new ndn.Name("/A")); +interest = new ndn.Interest("/A"); +interest = new ndn.Interest(interest); + +let name: ndn.Name = interest.getName(); +let b: boolean = interest.getCanBePrefix(); +b = interest.getMustBeFresh(); +const fh: ndn.DelegationSet = interest.getForwardingHint(); +let blob: ndn.Blob = interest.getNonce(); +let n: number = interest.getInterestLifetimeMilliseconds(); +blob = interest.getApplicationParameters(); +n = interest.getIncomingFaceId(); + +interest = interest.setName(name) + .setCanBePrefix(true) + .setMustBeFresh(true) + .setForwardingHint(fh) + .setInterestLifetimeMilliseconds(2000) + .setApplicationParameters(blob) + .setApplicationParameters(Buffer.alloc(4)) + .appendParametersDigestToName(); + +b = interest.matchesData(new ndn.Data()); +b = interest.matchesName(name); +interest.refreshNonce(); +const s: string = interest.toUri(); +interest.wireDecode(blob); +interest.wireDecode(Buffer.alloc(4)); +blob = interest.wireEncode(); + +fh.add(10, name); +n = fh.size(); +const del: ndn.DelegationSet.Delegation = fh.get(0); +n = del.getPreference(); +name = del.getName(); +b = fh.remove(name); diff --git a/types/ndn-js/test/key-chain.ts b/types/ndn-js/test/key-chain.ts new file mode 100644 index 0000000000..1f52abec86 --- /dev/null +++ b/types/ndn-js/test/key-chain.ts @@ -0,0 +1,48 @@ +/// +import ndn = require("ndn-js"); + +let kc = new ndn.KeyChain(); +kc = new ndn.KeyChain("pib-memory:", "tpm-memory:"); + +const kp: ndn.KeyParams = ndn.KeyChain.getDefaultKeyParams(); +const pib: ndn.Pib = kc.getPib(); +const tpm: ndn.Tpm = kc.getTpm(); + +let name = new ndn.Name("/key-name"); + +let id: ndn.PibIdentity = kc.createIdentityV2(name); +id = kc.createIdentityV2(name, kp); +kc.createIdentityV2(name, (id: ndn.PibIdentity) => {}); +kc.createIdentityV2(name, (id: ndn.PibIdentity) => {}, (err) => {}); +kc.createIdentityV2(name, kp, (id: ndn.PibIdentity) => {}); +kc.createIdentityV2(name, kp, (id: ndn.PibIdentity) => {}, (err) => {}); +kc.deleteIdentity(id); +kc.setDefaultIdentity(id); + +let key: ndn.PibKey = kc.createKey(id); +key = kc.createKey(id, kp); +kc.createKey(id, (key: ndn.PibKey) => {}); +kc.createKey(id, (key: ndn.PibKey) => {}, (err) => {}); +kc.createKey(id, kp, (key: ndn.PibKey) => {}); +kc.createKey(id, kp, (key: ndn.PibKey) => {}, (err) => {}); +kc.deleteKey(id, key); +kc.setDefaultKey(id, key); + +const cert: ndn.CertificateV2 = {}; +kc.addCertificate(key, cert); +kc.deleteCertificate(key, name); +kc.setDefaultCertificate(key, cert); + +let si: ndn.SigningInfo = new ndn.SigningInfo(); +si = new ndn.SigningInfo(ndn.SigningInfo.SignerType.ID, name); +si = new ndn.SigningInfo(si); +si = new ndn.SigningInfo(id); +si = new ndn.SigningInfo(key); +si = new ndn.SigningInfo("id:/my-identity"); +const signerType: ndn.SigningInfo.SignerType = si.getSignerType(); +name = si.getSignerName(); + +kc.sign(new ndn.Data(), si, (data: ndn.Data) => {}); +kc.sign(new ndn.Interest(), si, (interest: ndn.Interest) => {}); +kc.signWithSha256(new ndn.Data()); +kc.signWithSha256(new ndn.Interest()); diff --git a/types/ndn-js/test/memory-content-cache.ts b/types/ndn-js/test/memory-content-cache.ts new file mode 100644 index 0000000000..d809b7a442 --- /dev/null +++ b/types/ndn-js/test/memory-content-cache.ts @@ -0,0 +1,15 @@ +import ndn = require("ndn-js"); + +const face = new ndn.Face(); +let cache = new ndn.MemoryContentCache(face); +cache = new ndn.MemoryContentCache(face, 8000); + +cache.add(new ndn.Data()); +const n: number = cache.getMinimumCacheLifetime(); +cache.registerPrefix(new ndn.Name("/A"), + () => {}, + () => {}, + cache.getStorePendingInterest()); +cache.setInterestFilter(new ndn.Name("/A"), cache.getStorePendingInterest()); +cache.setMinimumCacheLifetime(5000); +cache.storePendingInterest(new ndn.Interest(), face); diff --git a/types/ndn-js/test/name.ts b/types/ndn-js/test/name.ts new file mode 100644 index 0000000000..beb7e3c26c --- /dev/null +++ b/types/ndn-js/test/name.ts @@ -0,0 +1,82 @@ +/// +import ndn = require("ndn-js"); + +const DIGEST = new ndn.Blob(Buffer.alloc(32)); + +let comp = new ndn.Name.Component(); +comp = new ndn.Name.Component([0x41]); +comp = new ndn.Name.Component(new ArrayBuffer(4), ndn.ComponentType.GENERIC); +comp = new ndn.Name.Component(Buffer.alloc(4), ndn.ComponentType.OTHER_CODE, 1000); +comp = new ndn.Name.Component(new Uint8Array(4)); +comp = new ndn.Name.Component("A"); +comp = new ndn.Name.Component(new ndn.Blob()); +comp = new ndn.Name.Component(comp); + +let n: number = comp.compare(comp); +let b: boolean = comp.equals(comp); +comp = ndn.Name.Component.fromImplicitSha256Digest(DIGEST); +comp = ndn.Name.Component.fromParametersSha256Digest(DIGEST); +n = comp.getOtherTypeCode(); +comp = comp.getSuccessor(); +const ct: ndn.ComponentType = comp.getType(); +let blob: ndn.Blob = comp.getValue(); +b = comp.isGeneric(); +b = comp.isImplicitSha256Digest(); +b = comp.isParametersSha256Digest(); +let s: string = comp.toEscapedString(); + +comp = ndn.Name.Component.fromNumber(200); +comp = ndn.Name.Component.fromNumber(200, ndn.ComponentType.OTHER_CODE, 1000); +comp = ndn.Name.Component.fromNumberWithMarker(200, 0xFD); +comp = ndn.Name.Component.fromSegment(0); +comp = ndn.Name.Component.fromSegmentOffset(0); +comp = ndn.Name.Component.fromSequenceNumber(1); +comp = ndn.Name.Component.fromTimestamp(123456789); +comp = ndn.Name.Component.fromVersion(4); + +b = comp.isSegment(); +b = comp.isSegmentOffset(); +b = comp.isSequenceNumber(); +b = comp.isTimestamp(); +b = comp.isVersion(); + +n = comp.toNumber(); +n = comp.toNumberWithMarker(0xFD); +n = comp.toSegment(); +n = comp.toSegmentOffset(); +n = comp.toSequenceNumber(); +n = comp.toTimestamp(); +n = comp.toVersion(); + +let name = new ndn.Name(); +name = new ndn.Name([new ndn.Name.Component("A"), new Uint8Array(2)]); +name = new ndn.Name("/A"); +name = new ndn.Name(name); + +name = name.append(ndn.Name.Component.fromSegment(4)) + .append("A", ndn.ComponentType.OTHER_CODE, 1000) + .appendImplicitSha256Digest(DIGEST) + .appendParametersSha256Digest(DIGEST) + .appendSegment(0) + .appendSegmentOffset(1) + .appendSequenceNumber(4) + .appendTimestamp(3) + .appendVersion(2); + +name.clear(); +n = name.compare(name); +n = name.compare(0, 2, name, 1, 3); +b = name.equals(name); +name = ndn.Name.fromEscapedString(s); +comp = name.get(2); +name = name.getPrefix(3); +name = name.getSubName(1).getSubName(1, 4); +name = name.getSuccessor(); +b = name.match(name); +name.set("/B"); +n = name.size(); +s = name.toUri(); +s = name.toUri(true); +name.wireDecode(blob); +name.wireDecode(Buffer.alloc(4)); +blob = name.wireEncode(); diff --git a/types/ndn-js/test/network-nack.ts b/types/ndn-js/test/network-nack.ts new file mode 100644 index 0000000000..8341742295 --- /dev/null +++ b/types/ndn-js/test/network-nack.ts @@ -0,0 +1,6 @@ +import ndn = require("ndn-js"); + +(nack: ndn.NetworkNack) => { + const n: number = nack.getOtherReasonCode(); + const reason: ndn.NetworkNack.Reason = nack.getReason(); +}; diff --git a/types/ndn-js/test/signature.ts b/types/ndn-js/test/signature.ts new file mode 100644 index 0000000000..65b809f1a6 --- /dev/null +++ b/types/ndn-js/test/signature.ts @@ -0,0 +1,66 @@ +import ndn = require("ndn-js"); + +let kl: ndn.KeyLocator = new ndn.KeyLocator(); +kl = new ndn.KeyLocator(kl); +const klt: ndn.KeyLocatorType = kl.getType(); +const name: ndn.Name = kl.getKeyName(); +let blob: ndn.Blob = kl.getKeyData(); +kl.setType(ndn.KeyLocatorType.KEY_LOCATOR_DIGEST); +kl.setKeyName(name); +kl.setKeyData(blob); +kl.clear(); + +let validity: ndn.ValidityPeriod = new ndn.ValidityPeriod(); +validity = new ndn.ValidityPeriod(validity); +validity = new ndn.ValidityPeriod(540109800000, 664156800000); +let b: boolean = validity.hasPeriod(); +let n: number = validity.getNotBefore(); +n = validity.getNotAfter(); +b = validity.isValid(); +b = validity.isValid(594172800000); +validity.equals(new ndn.ValidityPeriod()); +validity.clear(); + +let sigG = new ndn.GenericSignature(); +blob = sigG.getSignature(); +blob = sigG.getSignatureInfoEncoding(); +n = sigG.getTypeCode(); +sigG.setSignature(blob); +sigG.setSignatureInfoEncoding(blob); +sigG.setSignatureInfoEncoding(blob, 1000); +sigG = sigG.clone(); +let sig: ndn.Signature = sigG; + +let sig0 = new ndn.DigestSha256Signature(); +blob = sig0.getSignature(); +sig0.setSignature(blob); +sig0 = sig0.clone(); +sig = sig0; + +let sig1 = new ndn.Sha256WithRsaSignature(); +kl = sig1.getKeyLocator(); +blob = sig1.getSignature(); +validity = sig1.getValidityPeriod(); +sig1.setKeyLocator(kl); +sig1.setSignature(blob); +sig1.setValidityPeriod(validity); +sig1 = sig1.clone(); +sig = sig1; + +let sig3 = new ndn.Sha256WithEcdsaSignature(); +kl = sig3.getKeyLocator(); +blob = sig3.getSignature(); +validity = sig3.getValidityPeriod(); +sig3.setKeyLocator(kl); +sig3.setSignature(blob); +sig3.setValidityPeriod(validity); +sig3 = sig3.clone(); +sig = sig3; + +let sig4 = new ndn.HmacWithSha25Signature(); +kl = sig4.getKeyLocator(); +blob = sig4.getSignature(); +sig4.setKeyLocator(kl); +sig4.setSignature(blob); +sig4 = sig4.clone(); +sig = sig4; diff --git a/types/ndn-js/test/transport.ts b/types/ndn-js/test/transport.ts new file mode 100644 index 0000000000..707a5f0d55 --- /dev/null +++ b/types/ndn-js/test/transport.ts @@ -0,0 +1,14 @@ +import ndn = require("ndn-js"); + +const transport = new ndn.TcpTransport(); +const b: boolean = transport.isLocal(); + +let face = new ndn.Face(transport, new ndn.TcpTransport.ConnectionInfo("hobo.cs.arizona.edu", 9696)); +face = new ndn.Face(new ndn.UnixTransport(), new ndn.UnixTransport.ConnectionInfo("/run/nfd.sock")); +face = new ndn.Face(new ndn.WebSocketTransport(), new ndn.WebSocketTransport.ConnectionInfo("hobo.cs.arizona.edu", 9696)); + +face = new ndn.Face({host: 'hobo.cs.arizona.edu', port: 6363}); +face = new ndn.Face({getTransport: () => new ndn.UnixTransport(), + getConnectionInfo: () => new ndn.UnixTransport.ConnectionInfo("/run/nfd.sock")}); +face = new ndn.Face({getTransport: () => new ndn.UnixTransport(), + connectionInfo: new ndn.UnixTransport.ConnectionInfo("/run/nfd.sock")}); diff --git a/types/ndn-js/transport.d.ts b/types/ndn-js/transport.d.ts new file mode 100644 index 0000000000..9a2c4db918 --- /dev/null +++ b/types/ndn-js/transport.d.ts @@ -0,0 +1,40 @@ +export abstract class TransportConnectionInfo { +} + +export abstract class Transport { + static ConnectionInfo: TransportConnectionInfo; + isLocal(): boolean; +} + +export class TcpTransport extends Transport { +} + +export namespace TcpTransport { + class ConnectionInfo extends TransportConnectionInfo { + constructor(host: string, port: number); + equals(other: ConnectionInfo): boolean; + toString(): string; + } +} + +export class UnixTransport extends Transport { +} + +export namespace UnixTransport { + class ConnectionInfo extends TransportConnectionInfo { + constructor(filePath: string); + equals(other: ConnectionInfo): boolean; + toString(): string; + } +} + +export class WebSocketTransport extends Transport { +} + +export namespace WebSocketTransport { + class ConnectionInfo extends TransportConnectionInfo { + constructor(hostOrUri: string, port?: number); + equals(other: ConnectionInfo): boolean; + toString(): string; + } +} diff --git a/types/ndn-js/tsconfig.json b/types/ndn-js/tsconfig.json new file mode 100644 index 0000000000..3aaea5f6f1 --- /dev/null +++ b/types/ndn-js/tsconfig.json @@ -0,0 +1,32 @@ +{ + "compilerOptions": { + "module": "commonjs", + "lib": [ + "es6" + ], + "noImplicitAny": true, + "noImplicitThis": true, + "strictFunctionTypes": true, + "strictNullChecks": true, + "baseUrl": "../", + "typeRoots": [ + "../" + ], + "types": [], + "noEmit": true, + "forceConsistentCasingInFileNames": true + }, + "files": [ + "index.d.ts", + "test/blob.ts", + "test/data.ts", + "test/face.ts", + "test/interest.ts", + "test/key-chain.ts", + "test/memory-content-cache.ts", + "test/name.ts", + "test/network-nack.ts", + "test/signature.ts", + "test/transport.ts" + ] +} diff --git a/types/ndn-js/tslint.json b/types/ndn-js/tslint.json new file mode 100644 index 0000000000..3db14f85ea --- /dev/null +++ b/types/ndn-js/tslint.json @@ -0,0 +1 @@ +{ "extends": "dtslint/dt.json" }