;
diff --git a/src/app/tabs/tab.component.ts b/src/app/tabs/tab.component.ts
index 5945c352..9e717ad4 100644
--- a/src/app/tabs/tab.component.ts
+++ b/src/app/tabs/tab.component.ts
@@ -1,14 +1,14 @@
import { Component, EventEmitter, Input, OnInit, Output, TemplateRef, ViewChild } from '@angular/core';
@Component({
- selector: 'app-tab[name]',
- template: `
+ selector: 'app-tab[name]',
+ template: `
`,
- styles: [
- ]
+ styles: [],
+ standalone: false
})
export class TabComponent implements OnInit {
@ViewChild('tabTemplate', { read: TemplateRef }) public template!: TemplateRef;
diff --git a/src/app/tabs/tabs.component.ts b/src/app/tabs/tabs.component.ts
index dec7429e..e0d31178 100644
--- a/src/app/tabs/tabs.component.ts
+++ b/src/app/tabs/tabs.component.ts
@@ -2,8 +2,8 @@ import { AfterContentInit, Component, ContentChildren, Input, OnInit, QueryList
import { TabComponent } from './tab.component';
@Component({
- selector: 'app-tabs',
- template: `
+ selector: 'app-tabs',
+ template: `
@@ -22,8 +22,8 @@ import { TabComponent } from './tab.component';
`,
- styles: [
- `
+ styles: [
+ `
.main-container {
display: flex;
flex-flow: column;
@@ -54,7 +54,8 @@ import { TabComponent } from './tab.component';
visibility: hidden;
}
`
- ]
+ ],
+ standalone: false
})
export class TabsComponent implements OnInit, AfterContentInit {
diff --git a/src/app/topo/edge.component.ts b/src/app/topo/edge.component.ts
index c86c0d08..8f87c301 100644
--- a/src/app/topo/edge.component.ts
+++ b/src/app/topo/edge.component.ts
@@ -3,8 +3,8 @@ import { IEdge } from '../interfaces';
import { Topology } from './topo';
@Component({
- selector: 'topo-edge[topo][edge]',
- template: `
+ selector: 'topo-edge[topo][edge]',
+ template: `
Link
@@ -38,12 +38,13 @@ import { Topology } from './topo';
`,
- styles: [`
+ styles: [`
.label-btn {
float: right;
cursor: pointer;
}
- `]
+ `],
+ standalone: false
})
export class TopoEdgeComponent implements OnInit {
diff --git a/src/app/topo/global.component.ts b/src/app/topo/global.component.ts
index 66a66ad8..82d31069 100644
--- a/src/app/topo/global.component.ts
+++ b/src/app/topo/global.component.ts
@@ -3,8 +3,8 @@ import * as miniNDN from '../minindn-config';
import { Topology } from './topo';
@Component({
- selector: 'topo-global[topo]',
- template: `
+ selector: 'topo-global[topo]',
+ template: `
Global Operations
@@ -140,8 +140,8 @@ import { Topology } from './topo';
`,
- styles: [
- ]
+ styles: [],
+ standalone: false
})
export class TopoGlobalComponent {
diff --git a/src/app/topo/node.component.ts b/src/app/topo/node.component.ts
index 6f3e29b1..da37827b 100644
--- a/src/app/topo/node.component.ts
+++ b/src/app/topo/node.component.ts
@@ -4,8 +4,8 @@ import { INode } from '../interfaces';
import { Topology } from './topo';
@Component({
- selector: 'topo-node[topo][node]',
- template: `
+ selector: 'topo-node[topo][node]',
+ template: `
Node {{ node.label }}
@@ -83,8 +83,8 @@ import { Topology } from './topo';
`,
- styles: [
- ]
+ styles: [],
+ standalone: false
})
export class TopoNodeComponent implements OnInit {
diff --git a/src/app/topo/sidebar.component.ts b/src/app/topo/sidebar.component.ts
index bf8337a6..f1ab6002 100644
--- a/src/app/topo/sidebar.component.ts
+++ b/src/app/topo/sidebar.component.ts
@@ -2,8 +2,8 @@ import { Component, Input, OnInit } from '@angular/core';
import { Topology } from './topo';
@Component({
- selector: 'topo-sidebar[topo]',
- template: `
+ selector: 'topo-sidebar[topo]',
+ template: `
@@ -15,8 +15,8 @@ import { Topology } from './topo';
`,
- styles: [
- ]
+ styles: [],
+ standalone: false
})
export class TopoSidebarComponent implements OnInit {
diff --git a/src/app/topo/theme-toggle.component.ts b/src/app/topo/theme-toggle.component.ts
index a981aece..52877020 100644
--- a/src/app/topo/theme-toggle.component.ts
+++ b/src/app/topo/theme-toggle.component.ts
@@ -4,8 +4,8 @@ import { isDark } from './color.map';
const LS_KEY_DARK = 'force-dark';
@Component({
- selector: 'theme-toggle',
- template: `
+ selector: 'theme-toggle',
+ template: `
`,
- styles: [`
+ styles: [`
.theme-btn {
position: relative;
transform: scale(0.8) translateY(6px);
@@ -39,7 +39,8 @@ const LS_KEY_DARK = 'force-dark';
&.light { opacity: var(--is-dark); }
}
}
- `]
+ `],
+ standalone: false
})
export class ThemeToggleComponent implements OnInit {
constructor() { }
diff --git a/src/app/visualizer/visualizer.component.ts b/src/app/visualizer/visualizer.component.ts
index 841a2978..6b29bc44 100644
--- a/src/app/visualizer/visualizer.component.ts
+++ b/src/app/visualizer/visualizer.component.ts
@@ -15,9 +15,10 @@ const LF_KEYS = {
}
@Component({
- selector: 'app-visualizer',
- templateUrl: 'visualizer.component.html',
- styleUrls: ['visualizer.component.scss']
+ selector: 'app-visualizer',
+ templateUrl: 'visualizer.component.html',
+ styleUrls: ['visualizer.component.scss'],
+ standalone: false
})
export class VisualizerComponent implements OnInit {
@Input() public tlv?: TlvType;
diff --git a/src/assets/user-types.d.ts b/src/assets/user-types.d.ts
index 1f155df6..d35722fd 100644
--- a/src/assets/user-types.d.ts
+++ b/src/assets/user-types.d.ts
@@ -1,15 +1,13 @@
///
-import type * as asn1 from '@yoursunny/asn1';
+import * as asn1 from '@yoursunny/asn1';
import assert from 'tiny-invariant';
import { DataSet } from './esm';
-import { DefaultMap } from 'mnemonist';
import { Edge } from './esm';
import { FullItem } from 'vis-data/declarations/data-interface';
-import type { H3Transport } from '@ndn/quic-transport';
import { IdType } from './esm';
import { Network } from './esm';
-import { Node as Node_3 } from './esm';
+import { Node as Node_2 } from './esm';
import * as retry from 'retry';
import type { WebSocket as WebSocket_2 } from 'ws';
@@ -111,20 +109,12 @@ declare namespace AesKeyLength {
const Choices: readonly [128, 192, 256];
}
-/** Alternate expressions or expression in parens node. */
-declare class Alt extends Expr {
- choices: Expr[];
- constructor(choices?: Expr[]);
- protected exprParens(parent: Expr): boolean;
- protected exprToTokens(): Iterable;
-}
-
/** Specify several alternate patterns in "OR" relation. */
declare class AlternatePattern extends Pattern {
- readonly choices: Pattern[];
- constructor(choices?: Pattern[]);
- simplify(): Pattern;
+ readonly choices: readonly Pattern[];
+ constructor(choices: readonly Pattern[]);
protected matchState(state: MatchState): Iterable;
+ protected computeMatchLengthRange(): [min: number, max: number];
protected buildState(state: BuildState): Iterable;
}
@@ -157,7 +147,75 @@ declare class AltUriConverter {
readonly parseName: (input: string) => Name;
}
-declare const And: new () => Operator;
+/**
+ Merges user specified options with default options.
+
+ @example
+ ```
+ type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+ type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+ type SpecifiedOptions = {leavesOnly: true};
+
+ type Result = ApplyDefaultOptions;
+ //=> {maxRecursionDepth: 10; leavesOnly: true}
+ ```
+
+ @example
+ ```
+ // Complains if default values are not provided for optional options
+
+ type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+ type DefaultPathsOptions = {maxRecursionDepth: 10};
+ type SpecifiedOptions = {};
+
+ type Result = ApplyDefaultOptions;
+ // ~~~~~~~~~~~~~~~~~~~
+ // Property 'leavesOnly' is missing in type 'DefaultPathsOptions' but required in type '{ maxRecursionDepth: number; leavesOnly: boolean; }'.
+ ```
+
+ @example
+ ```
+ // Complains if an option's default type does not conform to the expected type
+
+ type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+ type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: 'no'};
+ type SpecifiedOptions = {};
+
+ type Result = ApplyDefaultOptions;
+ // ~~~~~~~~~~~~~~~~~~~
+ // Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+ ```
+
+ @example
+ ```
+ // Complains if an option's specified type does not conform to the expected type
+
+ type PathsOptions = {maxRecursionDepth?: number; leavesOnly?: boolean};
+ type DefaultPathsOptions = {maxRecursionDepth: 10; leavesOnly: false};
+ type SpecifiedOptions = {leavesOnly: 'yes'};
+
+ type Result = ApplyDefaultOptions;
+ // ~~~~~~~~~~~~~~~~
+ // Types of property 'leavesOnly' are incompatible. Type 'string' is not assignable to type 'boolean'.
+ ```
+ */
+declare type ApplyDefaultOptions<
+ Options extends object,
+ Defaults extends Simplify, RequiredKeysOf> & Partial, never>>>,
+ SpecifiedOptions extends Options,
+> =
+ IfAny
+ ? Extract extends never
+ ? Key
+ : never
+ : Key
+ ]: SpecifiedOptions[Key]
+ }> & Required> // `& Required` ensures that `ApplyDefaultOptions` is always assignable to `Required`
+ >>;
/**
Create a type that represents either the value or an array of the value.
@@ -212,31 +270,9 @@ T
*/
declare type ArrayValues = T[number];
-declare const ArrowL: new () => Operator;
-
/** Convert (Shared)ArrayBuffer(View) to DataView. */
declare function asDataView(a: ArrayBufferLike | ArrayBufferView): DataView;
-declare namespace ast {
- export {
- parse,
- Node_2 as Node,
- Expr,
- ComponentLit_2 as ComponentLit,
- Ident_2 as Ident,
- Call,
- Alt,
- Name_2 as Name,
- ComponentConstraintEq,
- ComponentConstraintTerm,
- ComponentConstraint,
- ComponentConstraintRel,
- SigningConstraint,
- Stmt,
- Schema
- }
-}
-
/** Convert (Shared)ArrayBuffer(View) to Uint8Array. */
declare function asUint8Array(a: ArrayBufferLike | ArrayBufferView): Uint8Array;
@@ -282,15 +318,6 @@ declare class BloomFilter {
declare interface BloomFilter extends Readonly {
}
-/** Tokens enclosed in braces. */
-declare class Brace extends Nested {
- constructor(left: T.Operator, mid?: Unit[]);
-}
-
-declare const BraceL: new () => Operator;
-
-declare const BraceR: new () => Operator;
-
/**
* A bridge passes packets between two logical forwarders.
* Disposing the bridge severs the link.
@@ -357,6 +384,10 @@ declare namespace Bridge {
* Ignored if both `.fwA` and `.fwB` are specified.
*/
fwOpts?: Forwarder.Options;
+ /** Face attributes from forwarder A to forwarder B. */
+ attrAB?: L3Face.Attributes;
+ /** Face attributes from forwarder A to forwarder B. */
+ attrBA?: L3Face.Attributes;
/**
* Relay options for packets from forwarder A to forwarder B.
* @defaultValue instant delivery
@@ -379,8 +410,8 @@ declare namespace Bridge {
routesBA?: readonly NameLike[];
}
/** Create a bridge that passes packets between two logical forwarders. */
- function create({ bridgeName, fwA, fwB, fwOpts, relayAB, relayBA, routesAB, routesBA, }?: CreateOptions): Bridge;
- type Renamed = Except & {
+ function create({ bridgeName, fwA, fwB, fwOpts, attrAB, attrBA, relayAB, relayBA, routesAB, routesBA, }?: CreateOptions): Bridge;
+ type Renamed = Except & {
[k in `fw${A | B}`]: Forwarder;
} & {
[k in `face${A | B}`]: FwFace;
@@ -413,15 +444,6 @@ declare class BuildState {
toString(): string;
}
-/** Internal function call node. */
-declare class Call extends Expr {
- func: string;
- args: Expr[];
- constructor(func: string, args?: Expr[]);
- protected exprParens(): boolean;
- protected exprToTokens(): Generator;
-}
-
/** Request to cancel a pending Interest. */
declare class CancelInterest implements FwPacket {
l3: Interest;
@@ -616,11 +638,12 @@ declare interface CertNameFields extends KeyNameFields {
* The captured variable contains the whole KeyLocator or certificate name that can
* be further recognized by {@link CertNaming.parseKeyName} and {@link CertNaming.parseCertName}.
*
- * Using the same {@link ConcatPattern}, the constructed name would be the subject name.
+ * Using the same {@link ConcatPattern}, the constructed name would be the subject name only.
* It can be passed to {@link \@ndn/keychain!KeyChain.getSigner} to find a key/certificate.
*/
declare class CertNamePattern extends Pattern {
protected matchState(state: MatchState): Iterable;
+ protected computeMatchLengthRange(): [min: number, max: number];
protected buildState(state: BuildState): Iterable;
}
@@ -720,10 +743,6 @@ declare class Closers extends Array imple
wait(): Promise;
}
-declare const Colon: new () => Operator;
-
-declare const Comma: new () => Operator;
-
declare interface CommonOptions {
/**
* Logical forwarder instance.
@@ -747,8 +766,6 @@ declare interface CommonOptions {
signal?: AbortSignal;
}
-declare function compile(schema: ast.Schema): TrustSchemaPolicy;
-
/**
* Name component.
*
@@ -818,69 +835,18 @@ declare namespace Component {
function compare(lhs: Component, rhs: Component): CompareResult;
}
-/** Component constraint node. */
-declare class ComponentConstraint extends ComponentConstraintEq {
- terms: ComponentConstraintTerm[];
- constructor(terms?: ComponentConstraintTerm[]);
- protected componentConstraintToTokens(): Generator;
-}
-
-/** Component constraint equation. */
-declare abstract class ComponentConstraintEq extends Node_2 {
- toTokens(): Iterable;
- protected static componentConstraintToTokens(node: ComponentConstraintEq, parentOp: string): Iterable;
- protected abstract componentConstraintToTokens(parentOp: string): Iterable;
-}
-
-/** Component constraint And/Or relation node. */
-declare class ComponentConstraintRel extends ComponentConstraintEq {
- left: ComponentConstraintEq;
- op: T.Operator;
- right: ComponentConstraintEq;
- constructor(left: ComponentConstraintEq, op: T.Operator, right: ComponentConstraintEq);
- protected componentConstraintToTokens(parentOp: string): Generator;
-}
-
-/** Component constraint term node. */
-declare class ComponentConstraintTerm extends Node_2 {
- tag: Ident_2;
- expr: Expr;
- constructor(tag: Ident_2, expr: Expr);
- toTokens(): Generator;
-}
-
/** Name component or component URI. */
declare type ComponentLike = Component | string;
-/** Name component literal token. */
-declare class ComponentLit extends Token {
- readonly comp: Component;
- constructor(comp: Component);
- toString(): string;
-}
-
-/** Name component literal node. */
-declare class ComponentLit_2 extends Expr {
- comp: Component;
- constructor(comp: Component);
- protected exprParens(): boolean;
- protected exprToTokens(): Generator;
-}
-
-declare interface Compression {
- compress: (input: Uint8Array) => Uint8Array;
- decompress: (compressed: Uint8Array) => Uint8Array;
-}
-
/** Concatenate Uint8Arrays. */
declare function concatBuffers(arr: readonly Uint8Array[], totalLength?: number): Uint8Array;
/** Concatenate several patterns. */
declare class ConcatPattern extends Pattern {
- readonly parts: Pattern[];
- constructor(parts?: Pattern[]);
- simplify(): Pattern;
+ readonly parts: readonly Pattern[];
+ constructor(parts: readonly Pattern[]);
protected matchState(state: MatchState, partIndex?: number): Iterable;
+ protected computeMatchLengthRange(): [min: number, max: number];
protected buildState(state: BuildState, partIndex?: number): Iterable;
}
@@ -997,6 +963,7 @@ declare class ConstPattern extends Pattern {
constructor(name: NameLike);
readonly name: Name;
protected matchState(state: MatchState): Iterable;
+ protected computeMatchLengthRange(): [min: number, max: number];
protected buildState(state: BuildState): Iterable;
}
@@ -1259,7 +1226,7 @@ declare function createVerifier(name: Name, algo: Signi
*/
declare function createVerifier(cert: Certificate, opts?: ImportCertOptions): Promise;
-/** Web Crypto API. */
+/** @deprecated Use `crypto` global object instead. */
declare const crypto_2: Crypto;
/**
@@ -1575,15 +1542,6 @@ declare interface DebugEntry_3 {
action: string;
}
-declare interface DebugEntry_4 {
- action: string;
- key?: number;
- name?: Name;
- ownIblt: IBLT;
- recvIblt?: IBLT;
- content?: Name[];
-}
-
/**
* An object that knows how to decode itself from TLV.
* @typeParam R - Result type.
@@ -1682,6 +1640,10 @@ declare interface Decrypter {
decrypt: (pkt: T) => Promise;
}
+declare type DefaultExceptOptions = {
+ requireExactProps: false;
+};
+
declare class DefaultServers {
private readonly nfw;
/** Server for ping */
@@ -1717,6 +1679,8 @@ declare type EcCurve = keyof typeof PointSizes;
declare namespace EcCurve {
const Default: EcCurve;
const Choices: readonly EcCurve[];
+ /** Detect EcCurve from SubjectPublicKeyInfo. */
+ function detectFromSpki(der: asn1.ElementBuffer): EcCurve;
}
/** Sha256WithEcdsa signing algorithm. */
@@ -1727,10 +1691,17 @@ declare namespace ECDSA {
interface GenParams {
/**
* EC curve.
- * @defaultValue P-256
+ *
+ * @defaultValue
+ * During key generation when {@link importPkcs8} is absent, the default is "P-256".
+ * During key import when {@link importPkcs8} is specified, this is auto-detected from SPKI.
*/
curve?: EcCurve;
- /** Import PKCS#8 private key and SPKI public key instead of generating. */
+ /**
+ * Import PKCS#8 private key and SPKI public key instead of generating.
+ *
+ * If {@link curve} is also specified, it must match the SPKI public key.
+ */
importPkcs8?: [pkcs8: Uint8Array, spki: Uint8Array];
}
interface Info {
@@ -2035,7 +2006,7 @@ declare namespace EvDecoder {
* that create event emitters. When the title is clicked, the emitter
* emits an open or close event to toggle the current visibility state.
*
- * ```html
+ * ```angular-ts
* @Component({
* selector: 'zippy',
* template: `
@@ -2169,12 +2140,13 @@ declare type EventMap_6 = {
state: PartialSubscriber.StateEvent;
};
-declare type EventMap_7 = {
- debug: CustomEvent;
-};
-
-/** Delete keys from a Set or Map until its size is below capacity. */
-declare function evict(capacity: number, ct: evict.Container): void;
+/**
+ * Delete keys from a Set or Map until its size is below capacity.
+ * @param capacity - Maximum size after eviction.
+ * @param ct - Container.
+ * @param deleteCallback - Callback before item is deleted.
+ */
+declare function evict(capacity: number, ct: evict.Container, deleteCallback?: (key: K) => void): void;
declare namespace evict {
type Container = Pick & Map, "delete" | "size" | "keys">;
@@ -2209,11 +2181,34 @@ declare namespace evict {
const fooWithoutB: FooWithoutB = {a: 1, b: '2'};
//=> errors at 'b': Type 'string' is not assignable to type 'undefined'.
+
+ // The `Omit` utility type doesn't work when omitting specific keys from objects containing index signatures.
+
+ // Consider the following example:
+
+ type UserData = {
+ [metadata: string]: string;
+ email: string;
+ name: string;
+ role: 'admin' | 'user';
+ };
+
+ // `Omit` clearly doesn't behave as expected in this case:
+ type PostPayload = Omit;
+ //=> type PostPayload = { [x: string]: string; [x: number]: string; }
+
+ // In situations like this, `Except` works better.
+ // It simply removes the `email` key while preserving all the other keys.
+ type PostPayload = Except;
+ //=> type PostPayload = { [x: string]: string; name: string; role: 'admin' | 'user'; }
```
@category Object
*/
-declare type Except = {
+declare type Except =
+ _Except>;
+
+declare type _Except> = {
[KeyType in keyof ObjectType as Filter]: ObjectType[KeyType];
} & (Options['requireExactProps'] extends true
? Partial>
@@ -2230,14 +2225,6 @@ declare type ExceptOptions = {
requireExactProps?: boolean;
};
-/** Expression node. */
-declare abstract class Expr extends Node_2 {
- toTokens(): Generator;
- protected static exprToTokens(node: Expr, parent?: Expr): Generator;
- protected abstract exprParens(parent: Expr): boolean;
- protected abstract exprToTokens(): Iterable;
-}
-
/** An TLV element that allows extension sub element. */
declare interface Extensible {
readonly [Extensible.TAG]: ExtensionRegistry;
@@ -2554,7 +2541,6 @@ declare class FullSync extends TypedEventTarget implements SyncProto
private readonly syncPrefix;
private readonly c;
private readonly codec;
- private readonly syncInterestNameCumulativeNElements;
private closed;
private readonly pFreshness;
private readonly pBuffer;
@@ -2571,7 +2557,7 @@ declare class FullSync extends TypedEventTarget implements SyncProto
get(prefix: Name): SyncNode | undefined;
add(prefix: Name): SyncNode;
private handleSyncInterest;
- private handleIncreaseSeqNum;
+ private readonly handleIncreaseSeqNum;
private sendSyncData;
private scheduleSyncInterest;
private sendSyncInterest;
@@ -2579,19 +2565,6 @@ declare class FullSync extends TypedEventTarget implements SyncProto
declare namespace FullSync {
interface Parameters extends PSyncCore.Parameters, PSyncCodec.Parameters {
- /**
- * If true, sync Interest name contains cumulative number of elements in IBLT.
- * @defaultValue true
- *
- * @remarks
- * PSync C++ library commit d83af5255db9c4a557264542647f7ccb281e6840 (2024-04-09) introduced an
- * algorithm change that involves a breaking change in sync Interest encoding.
- * To interact with PSync since this commit, set to true.
- * To interact with PSync before this commit, set to false.
- *
- * @experimental
- */
- syncInterestNameCumulativeNElements?: boolean;
}
interface Options {
/**
@@ -2641,7 +2614,7 @@ declare namespace FullSync {
* Interval between sync Interests, randomized within the range, in milliseconds.
* @defaultValue `[syncInterestLifetime/2+100,syncInterestLifetime/2+500]`
*/
- syncInterestInterval?: IntervalRange;
+ syncInterestInterval?: [min: number, max: number];
/**
* Verifier of sync reply Data packets.
* @defaultValue no verification
@@ -2701,9 +2674,9 @@ declare interface FwFace extends TypedEventTarget {
*
* This function has no effect if `FwFace.Attributes.advertiseFrom` is set to `false`.
*/
- addAnnouncement: (name: NameLike) => void;
+ addAnnouncement: (announcement: FwFace.PrefixAnnouncement) => void;
/** Remove a prefix announcement associated with the face. */
- removeAnnouncement: (name: NameLike) => void;
+ removeAnnouncement: (announcement: FwFace.PrefixAnnouncement) => void;
}
declare namespace FwFace {
@@ -2740,7 +2713,19 @@ declare namespace FwFace {
* - number: n-component prefix of route name.
* - {@link Name} or string: specified name.
*/
- type RouteAnnouncement = boolean | number | NameLike;
+ type RouteAnnouncement = boolean | number | PrefixAnnouncement;
+ /** Prefix announcement passed to {@link FwFace.addAnnouncement}. */
+ type PrefixAnnouncement = NameLike | PrefixAnnouncementObj;
+ /**
+ * Prefix announcement object.
+ * This would be passed to ReadvertiseDestination for its selective use.
+ *
+ * @remarks
+ * One implementation is `PrefixAnn` in \@ndn/nfdmgmt package.
+ */
+ interface PrefixAnnouncementObj {
+ readonly announced: Name;
+ }
type RxTxEventMap = Pick;
interface RxTxBase {
readonly attributes?: Attributes;
@@ -2888,6 +2873,22 @@ declare function generateSigningKey(name: NameLike,
*/
declare function generateSigningKey(keyChain: KeyChain, name: NameLike, ...a: SigningOptG): Promise<[NamedSigner, NamedVerifier]>;
+/**
+ * Retrieve or insert value in a Map-like container.
+ * @param ct - Map-like container.
+ * @param key - Map key.
+ * @param make - Function to create the value if needed.
+ * @returns Existing or newly created value.
+ */
+declare function getOrInsert(ct: C, key: Parameters[0] & Parameters[0], make: () => Parameters[1]): Parameters[1];
+
+declare namespace getOrInsert {
+ interface Container {
+ get: (key: any) => any | undefined;
+ set: (key: any, value: any) => void;
+ }
+}
+
export declare namespace globals {
/**
* The current node on which the code runs
@@ -2936,6 +2937,41 @@ export declare namespace globals {
const DCT: DCT;
}
+/** HTTP/3 transport. */
+declare class H3Transport extends Transport {
+ private readonly uri;
+ private readonly opts;
+ private readonly tr;
+ /** Whether current browser supports WebTransport. */
+ static readonly supported: boolean;
+ /**
+ * Create a transport and connect to remote endpoint.
+ * @param uri - Server URI.
+ * @param opts - WebTransport options.
+ */
+ static connect(uri: string, opts?: H3Transport.Options): Promise;
+ private constructor();
+ /** Report HTTP/3 maximum datagram size as MTU. */
+ get mtu(): number;
+ readonly rx: Transport.RxIterable;
+ tx(iterable: Transport.TxIterable): Promise;
+ /** Reopen the transport by connecting again with the same options. */
+ reopen(): Promise;
+}
+
+declare namespace H3Transport {
+ /** {@link H3Transport.connect} options. */
+ interface Options extends WebTransportOptions {
+ /**
+ * Connect timeout (in milliseconds).
+ * @defaultValue 10000
+ */
+ connectTimeout?: number;
+ }
+ /** Create a transport and add to forwarder. */
+ const createFace: L3Face.CreateFaceFunc<[uri: string, opts?: Options | undefined]>;
+}
+
/** 32-bit hash function. */
declare type HashFunction = (seed: number, input: Uint8Array) => number;
@@ -3055,13 +3091,6 @@ declare namespace IBLT {
}
}
-declare class IbltCodec {
- readonly ibltCompression: Compression;
- protected readonly ibltParams: IBLT.PreparedParameters;
- iblt2comp(iblt: IBLT): Component;
- comp2iblt(comp: Component): IBLT;
-}
-
declare type ICapturedPacket = [
/** Internal flags */
flags: number,
@@ -3083,24 +3112,6 @@ to?: IdType,
p?: Uint8Array
];
-/** Identifier token. */
-declare class Ident extends Token {
- readonly id: string;
- constructor(id: string);
- toString(): string;
-}
-
-/** Identifier node. */
-declare class Ident_2 extends Expr {
- id: string;
- /** Determine whether identifier could be a runtime variable name. */
- static isRuntime(id: string): boolean;
- static fromToken(token: N.Unit): Ident_2;
- constructor(id: string);
- protected exprParens(): boolean;
- protected exprToTokens(): Generator;
-}
-
declare interface IEdge extends Edge {
/** Initialized flag */
init?: boolean;
@@ -3114,6 +3125,29 @@ declare interface IEdge extends Edge {
declare type If = Cond extends true ? True : Cond extends false ? False : Unknown;
+/**
+ An if-else-like type that resolves depending on whether the given type is `any`.
+
+ @see {@link IsAny}
+
+ @example
+ ```
+ import type {IfAny} from 'type-fest';
+
+ type ShouldBeTrue = IfAny;
+ //=> true
+
+ type ShouldBeBar = IfAny<'not any', 'foo', 'bar'>;
+ //=> 'bar'
+ ```
+
+ @category Type Guard
+ @category Utilities
+ */
+declare type IfAny = (
+ IsAny extends true ? TypeIfAny : TypeIfNotAny
+);
+
declare interface IFibEntry {
/** Name prefix */
prefix: PfxT;
@@ -3189,7 +3223,7 @@ declare interface ImportCertOptions {
now?: ValidityPeriod.TimestampInput;
}
-declare interface INode extends Node_3 {
+declare interface INode extends Node_2 {
/** Initialized flag */
init?: boolean;
nfw?: NFW;
@@ -3281,8 +3315,6 @@ declare namespace Interest {
function makeModifyFunc(input?: Modify): ModifyFunc;
}
-declare type IntervalRange = [min: number, max: number];
-
/** Connected Pty */
declare interface IPty {
id: string;
@@ -3297,6 +3329,36 @@ declare interface IPty {
initBuf?: Uint8Array;
}
+/**
+ Returns a boolean for whether the given type is `any`.
+
+ @link https://stackoverflow.com/a/49928360/1490091
+
+ Useful in type utilities, such as disallowing `any`s to be passed to a function.
+
+ @example
+ ```
+ import type {IsAny} from 'type-fest';
+
+ const typedObject = {a: 1, b: 2} as const;
+ const anyObject: any = {a: 1, b: 2};
+
+ function get extends true ? {} : Record), K extends keyof O = keyof O>(obj: O, key: K) {
+ return obj[key];
+ }
+
+ const typedA = get(typedObject, 'a');
+ //=> 1
+
+ const anyA = get(anyObject, 'a');
+ //=> any
+ ```
+
+ @category Type Guard
+ @category Utilities
+ */
+declare type IsAny = 0 extends 1 & NoInfer_2 ? true : false;
+
/** Determine whether the name is a certificate name. */
declare function isCertName(name: Name): boolean;
@@ -3327,8 +3389,8 @@ declare function isCertName(name: Name): boolean;
@category Utilities
*/
declare type IsEqual =
- (() => G extends A ? 1 : 2) extends
- (() => G extends B ? 1 : 2)
+ (() => G extends A & G | G ? 1 : 2) extends
+ (() => G extends B & G | G ? 1 : 2)
? true
: false;
@@ -3591,7 +3653,8 @@ declare namespace keychain {
KeyStore,
CertStore,
KeyChain,
- KeyChainSerialized
+ KeyChainSerialized,
+ KeyChainExternal
}
}
export { keychain }
@@ -3604,6 +3667,36 @@ declare class KeyChainCertSource implements CertSource {
findCerts(keyLocator: Name): AsyncIterable;
}
+/**
+ * KeyChain adapter that copies from an external KeyChain.
+ */
+declare abstract class KeyChainExternal extends KeyChainSerialized {
+ protected readonly algoList: readonly CryptoAlgorithm[];
+ readonly needJwk: boolean;
+ private readonly insertKeyLoader;
+ private cached?;
+ protected constructor(algoList: readonly CryptoAlgorithm[], needJwk?: boolean);
+ /** Copy the external KeyChain to `dest`. */
+ protected abstract copyTo(dest: KeyChain): Promisable;
+ private load;
+ protected sListKeys(prefix: Name): Promise;
+ protected sGetKeyPair(name: Name): Promise;
+ protected sInsertKey(name: Name, stored: KeyStore.StoredKey): Promise;
+ /** Insert a key pair in external KeyChain. */
+ protected abstract eInsertKey(keyPair: KeyStore.KeyPair): Promisable;
+ protected sDeleteKey(name: Name): Promise;
+ /** Delete a key pair in external KeyChain. */
+ protected abstract eDeleteKey(name: Name): Promisable;
+ protected sListCerts(prefix: Name): Promise;
+ protected sGetCert(name: Name): Promise;
+ protected sInsertCert(cert: Certificate): Promise;
+ /** Insert a certificate in external KeyChain. */
+ protected abstract eInsertCert(cert: Certificate): Promisable;
+ protected sDeleteCert(name: Name): Promise;
+ /** Delete a certificate in external KeyChain. */
+ protected abstract eDeleteCert(name: Name): Promisable;
+}
+
/**
* KeyChain adapter that serializes function calls.
*
@@ -3874,10 +3967,10 @@ declare namespace L3Face {
* @defaultValue `false`.
* This default is set in {@link CreateFaceFunc} but could be different elsewhere.
* @remarks
- * This attribute passed to {@link \@ndn/fw!FwFace.Attributes.advertiseFrom}. With the default
- * `false` value, routes "announced" by an L3Face would not be readvertised to
- * {@link \@ndn/fw!ReadvertiseDestination}s, so that remote forwarders would not depend on the
- * local logical forwarder to forward Interests between L3Faces.
+ * This attribute is passed to {@link \@ndn/fw!FwFace.Attributes.advertiseFrom}. With the
+ * default `false` value, routes "announced" by an L3Face would not be readvertised to
+ * {@link \@ndn/fw!ReadvertiseDestination}s, so that the local logical forwarder would not
+ * forward Interests between L3Faces connected to different remote forwarders.
*/
advertiseFrom?: boolean;
}
@@ -4019,9 +4112,6 @@ declare namespace LLVerify {
}
}
-/** Load policy from VerSec syntax. */
-declare function load(input: string): TrustSchemaPolicy;
-
/**
* Acquire a semaphore for unlocking via Disposable.
* @param semaphore - Semaphore or Mutex from `wait-your-turn` package.
@@ -4252,29 +4342,6 @@ declare namespace makePSyncCompatParam {
}
}
-/** Create algorithm parameters to be compatible with DNMP-v2 syncps library. */
-declare function makeSyncpsCompatParam({ keyToBufferLittleEndian, expectedEntries, }?: makeSyncpsCompatParam.Options): SyncpsPubsub.Parameters;
-
-declare namespace makeSyncpsCompatParam {
- interface Options {
- /**
- * Whether to use little endian when converting a uint32 key to a byte array.
- * @defaultValue true
- *
- * @remarks
- * ndn-ind behaves differently on big endian and little endian machines,
- * {@link https://github.com/operantnetworks/ndn-ind/blob/dd934a7a5106cda6ea14675554427e12df1ce18f/src/lite/util/crypto-lite.cpp#L114}
- * This must be set to match other peers.
- */
- keyToBufferLittleEndian?: boolean;
- /**
- * Expected number of IBLT entries, i.e. expected number of updates in a sync cycle.
- * @defaultValue 85
- */
- expectedEntries?: number;
- }
-}
-
/** Context of matching a name. */
declare class MatchState {
readonly name: Name;
@@ -4289,7 +4356,10 @@ declare class MatchState {
constructor(name: Name, pos?: number, vars?: Vars);
/** Length of unconsumed name. */
get tailLength(): number;
- /** Get first i components of unconsumed name. */
+ /**
+ * Get first i components of unconsumed name.
+ * @param i - Number of components, must be non-negative.
+ */
tail(i?: number): Name;
/** Whether the input name has been accepted by pattern. */
get accepted(): boolean;
@@ -4309,6 +4379,46 @@ declare class MatchState {
toString(): string;
}
+/**
+ Merge two types into a new type. Keys of the second type overrides keys of the first type.
+
+ @example
+ ```
+ import type {Merge} from 'type-fest';
+
+ interface Foo {
+ [x: string]: unknown;
+ [x: number]: unknown;
+ foo: string;
+ bar: symbol;
+ }
+
+ type Bar = {
+ [x: number]: number;
+ [x: symbol]: unknown;
+ bar: Date;
+ baz: boolean;
+ };
+
+ export type FooBar = Merge;
+ // => {
+ // [x: string]: unknown;
+ // [x: number]: number;
+ // [x: symbol]: unknown;
+ // foo: string;
+ // bar: Date;
+ // baz: boolean;
+ // }
+ ```
+
+ @category Object
+ */
+declare type Merge =
+Simplify<
+SimpleMerge, PickIndexSignature>
+& SimpleMerge, OmitIndexSignature>
+>;
+
declare const modifyFields: readonly ["canBePrefix", "mustBeFresh", "fwHint", "lifetime", "hopLimit"];
export declare const modules: {
@@ -4335,18 +4445,6 @@ declare class Mutex extends Semaphore {
constructor();
}
-declare namespace N {
- export {
- scan_2 as scan,
- split,
- unParen,
- toTokens,
- Unit,
- Paren,
- Brace
- }
-}
-
/** Nack packet. */
declare class Nack {
interest: Interest;
@@ -4463,14 +4561,6 @@ declare namespace Name {
function compare(lhs: Name, rhs: Name): CompareResult;
}
-/** Name node. */
-declare class Name_2 extends Expr {
- comps: Expr[];
- constructor(comps?: Expr[]);
- protected exprParens(parent: Expr): boolean;
- protected exprToTokens(): Iterable;
-}
-
/** Named private key or secret key decrypter. */
declare interface NamedDecrypter extends Key>, LLDecrypt.Key {
}
@@ -4577,13 +4667,6 @@ declare namespace NamingConvention {
function isConvention(obj: any): obj is NamingConvention;
}
-declare class Nested {
- readonly left: T.Operator;
- readonly mid: Unit[];
- right: T.Operator;
- protected constructor(left: T.Operator, mid: Unit[], right: T.Operator);
-}
-
declare class NFW {
readonly topo: Topology;
readonly nodeId: IdType;
@@ -4685,10 +4768,7 @@ declare namespace NNI {
}): bigint;
}
-/** AST node. */
-declare abstract class Node_2 {
- abstract toTokens(): Iterable;
-}
+declare type NoInfer_2 = T extends infer U ? U : never;
/** Encrypter and decrypter that do nothing. */
declare const noopEncryption: Encrypter & Decrypter;
@@ -4705,8 +4785,6 @@ declare const nullSigner: Signer;
/**
* A representation of any set of values over any amount of time. This is the most basic building block
* of RxJS.
- *
- * @class Observable
*/
declare class Observable implements Subscribable {
/**
@@ -4716,10 +4794,9 @@ declare class Observable implements Subscribable {
/**
* @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
*/
- operator: Operator_2 | undefined;
+ operator: Operator | undefined;
/**
- * @constructor
- * @param {Function} subscribe the function that is called when the Observable is
+ * @param subscribe The function that is called when the Observable is
* initially subscribed to. This function is given a Subscriber, to which new values
* can be `next`ed, or an `error` method can be called to raise an error, or
* `complete` can be called to notify of a successful completion.
@@ -4727,26 +4804,22 @@ declare class Observable implements Subscribable {
constructor(subscribe?: (this: Observable, subscriber: Subscriber_2) => TeardownLogic);
/**
* Creates a new Observable by calling the Observable constructor
- * @owner Observable
- * @method create
- * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
- * @return {Observable} a new observable
- * @nocollapse
+ * @param subscribe the subscriber function to be passed to the Observable constructor
+ * @return A new observable.
* @deprecated Use `new Observable()` instead. Will be removed in v8.
*/
static create: (...args: any[]) => any;
/**
* Creates a new Observable, with this Observable instance as the source, and the passed
* operator defined as the new observable's operator.
- * @method lift
* @param operator the operator defining the operation to take on the observable
- * @return a new observable with the Operator applied
+ * @return A new observable with the Operator applied.
* @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
* If you have implemented an operator using `lift`, it is recommended that you create an
* operator by simply returning `new Observable()` directly. See "Creating new operators from
* scratch" section here: https://rxjs.dev/guide/operators
*/
- lift(operator?: Operator_2): Observable;
+ lift(operator?: Operator): Observable;
subscribe(observerOrNext?: Partial> | ((value: T) => void)): Subscription_2;
/** @deprecated Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments */
subscribe(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): Subscription_2;
@@ -4790,9 +4863,9 @@ declare class Observable implements Subscribable {
* // 'Total: 6'
* ```
*
- * @param next a handler for each value emitted by the observable
- * @return a promise that either resolves on observable completion or
- * rejects with the handled error
+ * @param next A handler for each value emitted by the observable.
+ * @return A promise that either resolves on observable completion or
+ * rejects with the handled error.
*/
forEach(next: (value: T) => void): Promise;
/**
@@ -4864,26 +4937,152 @@ declare interface Observer {
complete: () => void;
}
-/** Operator token. */
-declare abstract class Operator extends Token {
- /** Operator short string. */
- abstract get operator(): string;
- /** Operator nesting level. */
- abstract get nest(): number;
- /** If true, when this token appears at end of line, a comma should be inserted. */
- abstract get autoCommaAfter(): boolean;
-}
+/**
+ Omit any index signatures from the given object type, leaving only explicitly defined properties.
+
+ This is the counterpart of `PickIndexSignature`.
+
+ Use-cases:
+ - Remove overly permissive signatures from third-party types.
+
+ This type was taken from this [StackOverflow answer](https://stackoverflow.com/a/68261113/420747).
+
+ It relies on the fact that an empty object (`{}`) is assignable to an object with just an index signature, like `Record`, but not to an object with explicitly defined keys, like `Record<'foo' | 'bar', unknown>`.
+
+ (The actual value type, `unknown`, is irrelevant and could be any type. Only the key type matters.)
+
+ ```
+ const indexed: Record = {}; // Allowed
+
+ const keyed: Record<'foo', unknown> = {}; // Error
+ // => TS2739: Type '{}' is missing the following properties from type 'Record<"foo" | "bar", unknown>': foo, bar
+ ```
+
+ Instead of causing a type error like the above, you can also use a [conditional type](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html) to test whether a type is assignable to another:
+
+ ```
+ type Indexed = {} extends Record
+ ? '✅ `{}` is assignable to `Record`'
+ : '❌ `{}` is NOT assignable to `Record`';
+ // => '✅ `{}` is assignable to `Record`'
+
+ type Keyed = {} extends Record<'foo' | 'bar', unknown>
+ ? "✅ `{}` is assignable to `Record<'foo' | 'bar', unknown>`"
+ : "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`";
+ // => "❌ `{}` is NOT assignable to `Record<'foo' | 'bar', unknown>`"
+ ```
+
+ Using a [mapped type](https://www.typescriptlang.org/docs/handbook/2/mapped-types.html#further-exploration), you can then check for each `KeyType` of `ObjectType`...
+
+ ```
+ import type {OmitIndexSignature} from 'type-fest';
+
+ type OmitIndexSignature = {
+ [KeyType in keyof ObjectType // Map each key of `ObjectType`...
+ ]: ObjectType[KeyType]; // ...to its original value, i.e. `OmitIndexSignature == Foo`.
+ };
+ ```
+
+ ...whether an empty object (`{}`) would be assignable to an object with that `KeyType` (`Record`)...
+
+ ```
+ import type {OmitIndexSignature} from 'type-fest';
+
+ type OmitIndexSignature = {
+ [KeyType in keyof ObjectType
+ // Is `{}` assignable to `Record`?
+ as {} extends Record
+ ? ... // ✅ `{}` is assignable to `Record`
+ : ... // ❌ `{}` is NOT assignable to `Record`
+ ]: ObjectType[KeyType];
+ };
+ ```
+
+ If `{}` is assignable, it means that `KeyType` is an index signature and we want to remove it. If it is not assignable, `KeyType` is a "real" key and we want to keep it.
+
+ @example
+ ```
+ import type {OmitIndexSignature} from 'type-fest';
+
+ interface Example {
+ // These index signatures will be removed.
+ [x: string]: any
+ [x: number]: any
+ [x: symbol]: any
+ [x: `head-${string}`]: string
+ [x: `${string}-tail`]: string
+ [x: `head-${string}-tail`]: string
+ [x: `${bigint}`]: string
+ [x: `embedded-${number}`]: string
+
+ // These explicitly defined keys will remain.
+ foo: 'bar';
+ qux?: 'baz';
+ }
+
+ type ExampleWithoutIndexSignatures = OmitIndexSignature;
+ // => { foo: 'bar'; qux?: 'baz' | undefined; }
+ ```
+
+ @see PickIndexSignature
+ @category Object
+ */
+declare type OmitIndexSignature = {
+ [KeyType in keyof ObjectType as {} extends Record
+ ? never
+ : KeyType]: ObjectType[KeyType];
+};
/***
* @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
*/
-declare interface Operator_2 {
+declare interface Operator {
call(subscriber: Subscriber_2, source: any): TeardownLogic;
}
declare interface OperatorFunction extends UnaryFunction, Observable> {
}
+/**
+ Extract all optional keys from the given type.
+
+ This is useful when you want to create a new type that contains different type values for the optional keys only.
+
+ @example
+ ```
+ import type {OptionalKeysOf, Except} from 'type-fest';
+
+ interface User {
+ name: string;
+ surname: string;
+
+ luckyNumber?: number;
+ }
+
+ const REMOVE_FIELD = Symbol('remove field symbol');
+ type UpdateOperation = Except, OptionalKeysOf> & {
+ [Key in OptionalKeysOf]?: Entity[Key] | typeof REMOVE_FIELD;
+ };
+
+ const update1: UpdateOperation = {
+ name: 'Alice'
+ };
+
+ const update2: UpdateOperation = {
+ name: 'Bob',
+ luckyNumber: REMOVE_FIELD
+ };
+ ```
+
+ @category Utilities
+ */
+declare type OptionalKeysOf =
+ BaseType extends unknown // For distributing `BaseType`
+ ? (keyof {
+ [Key in keyof BaseType as BaseType extends Record ? never : Key]: never
+ }) & (keyof BaseType) // Intersect with `keyof BaseType` to ensure result of `OptionalKeysOf` is always assignable to `keyof BaseType`
+ : never;
+
/** StructBuilder field options. */
declare interface Options extends EvDecoder.RuleOptions {
/**
@@ -4913,12 +5112,10 @@ declare interface Options;
}
-declare const Or: new () => Operator;
-
/**
* A reference to an Angular output.
*
- * @developerPreview
+ * @publicAPI
*/
declare interface OutputRef {
/**
@@ -4938,7 +5135,7 @@ declare interface OutputRef {
* Note: Angular will automatically clean up subscriptions
* when the directive/component of the output is destroyed.
*
- * @developerPreview
+ * @publicAPI
*/
declare interface OutputRefSubscription {
unsubscribe(): void;
@@ -4955,10 +5152,10 @@ declare interface OutputRefSubscription {
* are present, and then the built name must match all branches.
*/
declare class OverlapPattern extends Pattern {
- readonly branches: Pattern[];
- constructor(branches?: Pattern[]);
- simplify(): Pattern;
+ readonly branches: readonly Pattern[];
+ constructor(branches: readonly Pattern[]);
protected matchState(state: MatchState, branchIndex?: number, lastMatch?: MatchState): Iterable;
+ protected computeMatchLengthRange(): [min: number, max: number];
protected buildState(state: BuildState): Iterable;
}
@@ -5037,18 +5234,6 @@ declare class ParamsDigestComp extends DigestComp {
findIn(name: Name, matchPlaceholder?: boolean): number;
}
-/** Tokens enclosed in parens. */
-declare class Paren extends Nested {
- constructor(left: T.Operator, mid?: Unit[]);
-}
-
-declare const ParenL: new () => Operator;
-
-declare const ParenR: new () => Operator;
-
-/** Parse a schema. */
-declare function parse(tokens: Iterable): Schema;
-
/**
* Parse a certificate name into fields.
* @param name - Must be a certificate name.
@@ -5228,8 +5413,6 @@ declare namespace PartialSubscriber {
/** Structure of a name. */
declare abstract class Pattern {
- /** Convert to a simpler pattern if possible. */
- simplify(): Pattern;
/**
* Determine whether a name matches the structure of this pattern.
* @param name - Input name.
@@ -5242,6 +5425,16 @@ declare abstract class Pattern {
* @returns Iterable of potential matches.
*/
protected abstract matchState(state: MatchState): Iterable;
+ /**
+ * Determine minimum and maximum match length.
+ *
+ * @remarks
+ * This optimization is used in {@link match} for early rejection of input names that are
+ * either too short or too long.
+ */
+ get matchLengthRange(): [min: number, max: number];
+ private matchLengthRange_?;
+ protected abstract computeMatchLengthRange(): [min: number, max: number];
/**
* Build names following the structure of this pattern.
* @param varsL - Sets of variables to be replaced into the name.
@@ -5270,6 +5463,57 @@ declare namespace pattern {
}
}
+/**
+ Pick only index signatures from the given object type, leaving out all explicitly defined properties.
+
+ This is the counterpart of `OmitIndexSignature`.
+
+ @example
+ ```
+ import type {PickIndexSignature} from 'type-fest';
+
+ declare const symbolKey: unique symbol;
+
+ type Example = {
+ // These index signatures will remain.
+ [x: string]: unknown;
+ [x: number]: unknown;
+ [x: symbol]: unknown;
+ [x: `head-${string}`]: string;
+ [x: `${string}-tail`]: string;
+ [x: `head-${string}-tail`]: string;
+ [x: `${bigint}`]: string;
+ [x: `embedded-${number}`]: string;
+
+ // These explicitly defined keys will be removed.
+ ['kebab-case-key']: string;
+ [symbolKey]: string;
+ foo: 'bar';
+ qux?: 'baz';
+ };
+
+ type ExampleIndexSignature = PickIndexSignature;
+ // {
+ // [x: string]: unknown;
+ // [x: number]: unknown;
+ // [x: symbol]: unknown;
+ // [x: `head-${string}`]: string;
+ // [x: `${string}-tail`]: string;
+ // [x: `head-${string}-tail`]: string;
+ // [x: `${bigint}`]: string;
+ // [x: `embedded-${number}`]: string;
+ // }
+ ```
+
+ @see OmitIndexSignature
+ @category Object
+ */
+declare type PickIndexSignature = {
+ [KeyType in keyof ObjectType as {} extends Record
+ ? KeyType
+ : never]: ObjectType[KeyType];
+};
+
declare const PointSizes: {
readonly "P-256": 32;
readonly "P-384": 48;
@@ -5326,43 +5570,13 @@ declare namespace PolicyVerifier {
}
}
-/** Position in schema document. */
-declare class Position {
- /**
- * Constructor
- * @param line - 0-based line number.
- * @param column - 0-based column number.
- */
- constructor(line?: number, column?: number);
- /** 1-based line number, if known. */
- readonly line?: number;
- /** 1-based column number, if known. */
- readonly column?: number;
- toString(): string;
-}
-
-declare namespace Position {
- const UNKNOWN: Position;
- interface WithPosition {
- position?: Position;
- }
- /** Extract first valid position from a sequence. */
- function from(input?: WithPosition | Iterable): Position;
-}
-
-/** Serialize a token stream. */
-declare function print_2(tokens: Iterable): string;
-
-/** Print policy to VerSec syntax. */
-declare function print_3(policy: TrustSchemaPolicy): string;
-
/** Print policy as ECMAScript module. */
declare function printESM(policy: TrustSchemaPolicy): string;
declare namespace printESM {
interface Context {
indent: string;
- imports: DefaultMap>;
+ addImport: (module: string, ...identifier: readonly string[]) => void;
}
interface PrintableFilter extends VariablePattern.Filter {
printESM: (ctx: Context) => string;
@@ -5454,7 +5668,7 @@ declare interface ProducerOptions extends CommonOptions {
* *Null*), it is automatically signed with this signer.
*
* This option does not apply to Data packets manually inserted into `.dataBuffer`. To auto-sign
- * those packet, specify {@link DataStoreBuffer.Options.dataSigner} in addition.
+ * those packets, specify {@link DataStoreBuffer.Options.dataSigner} in addition.
*/
dataSigner?: Signer;
/**
@@ -5564,14 +5778,12 @@ declare namespace psync {
SyncProtocol,
SyncNode,
SyncUpdate,
- IBLT,
FullSync,
+ IBLT,
makePSyncCompatParam,
PSyncZlib,
PartialPublisher,
- PartialSubscriber,
- makeSyncpsCompatParam,
- SyncpsPubsub
+ PartialSubscriber
}
}
export { psync }
@@ -5579,15 +5791,20 @@ export { psync }
declare class PSyncCodec {
protected readonly ibltParams: IBLT.PreparedParameters;
constructor(p: PSyncCodec.Parameters, ibltParams: IBLT.PreparedParameters);
- state2buffer(state: PSyncCore.State): Uint8Array;
- buffer2state(buffer: Uint8Array): PSyncCore.State;
+ iblt2comp(iblt: IBLT): Promise;
+ comp2iblt(comp: Component): Promise;
+ state2buffer(state: PSyncCore.State): Promise;
+ buffer2state(buffer: Uint8Array): Promise;
}
-declare interface PSyncCodec extends Readonly, IbltCodec {
+declare interface PSyncCodec extends Readonly {
}
declare namespace PSyncCodec {
- type Compression = Compression;
+ interface Compression {
+ compress: (input: Uint8Array) => Promisable;
+ decompress: (compressed: Uint8Array) => Promisable;
+ }
interface Parameters {
/** Compression method for IBLT in name component. */
ibltCompression: Compression;
@@ -5704,7 +5921,7 @@ declare class RandomIvGen extends IvGen {
/**
* Create a random jitter generator function.
- * @param r - Jitter factor around 1.
+ * @param r - Jitter factor around median.
* @param x - Median value.
* @returns Jitter generator function.
*
@@ -5715,6 +5932,11 @@ declare class RandomIvGen extends IvGen {
*/
declare function randomJitter(r: number, x?: number): () => number;
+declare namespace randomJitter {
+ /** Create a random generator function between `[min,max]`. */
+ function between(min: number, max: number): () => number;
+}
+
/**
* A destination of prefix advertisement.
*
@@ -5744,8 +5966,20 @@ declare abstract class ReadvertiseDestination {
withdraw(name: Name): void;
protected restart(name: Name, record: ReadvertiseDestination.Record): void;
private process;
- /** Create per-prefix state. */
+ /**
+ * Create per-prefix state.
+ *
+ * @remarks
+ * Must override if State type parameter is changed from the default.
+ */
protected makeState(name: Name): State;
+ /**
+ * Retrieve application supplied prefix announcement objects.
+ *
+ * @remarks
+ * This is only available during {@link makeState} and {@link doAdvertise}.
+ */
+ protected listAnnouncementObjs(name: Name): Iterable;
/** Advertise a prefix once. */
protected abstract doAdvertise(name: Name, state: State): Promise;
/** Withdraw a prefix once. */
@@ -5808,6 +6042,35 @@ declare class Reorder {
shift(): T[];
}
+/**
+ Extract all required keys from the given type.
+
+ This is useful when you want to create a new type that contains different type values for the required keys only or use the list of keys for validation purposes, etc...
+
+ @example
+ ```
+ import type {RequiredKeysOf} from 'type-fest';
+
+ declare function createValidation = RequiredKeysOf>(field: Key, validator: (value: Entity[Key]) => boolean): ValidatorFn;
+
+ interface User {
+ name: string;
+ surname: string;
+
+ luckyNumber?: number;
+ }
+
+ const validator1 = createValidation('name', value => value.length < 25);
+ const validator2 = createValidation('surname', value => value.length < 25);
+ ```
+
+ @category Utilities
+ */
+declare type RequiredKeysOf =
+ BaseType extends unknown // For distributing `BaseType`
+ ? Exclude>
+ : never;
+
/**
* Function to generate retransmission intervals.
*
@@ -5913,19 +6176,6 @@ declare function rxFromStream(conn: NodeJS.ReadableStream): Transport.RxIterable
*/
declare function safeIter(iterable: AnyIterable, onError?: (err?: unknown) => void): AsyncIterableIterator;
-/** Tokenize a schema document. */
-declare function scan(doc: string): Iterable;
-
-/** Scan tokens into a sequences of units on the same nesting level. */
-declare function scan_2(tokens: Iterable): Unit[];
-
-/** Schema document node. */
-declare class Schema extends Node_2 {
- stmts: Stmt[];
- constructor(stmts?: Stmt[]);
- toTokens(): Generator;
-}
-
/** Named secret key. */
declare type SecretKey = Key<"secret">;
@@ -6223,13 +6473,6 @@ declare const SigningAlgorithmListFull: readonly SigningAlgorithm[];
*/
declare const SigningAlgorithmListSlim: readonly SigningAlgorithm[];
-/** Signing constraint node. */
-declare class SigningConstraint extends Node_2 {
- signers: Ident_2[];
- constructor(signers?: Ident_2[]);
- toTokens(): Generator;
-}
-
declare type SigningOptG = {} extends G ? [
SigningAlgorithm,
G?
@@ -6247,6 +6490,10 @@ declare const SigType: {
readonly Null: 200;
};
+declare type SimpleMerge = {
+ [Key in keyof Destination as Key extends keyof Source ? never : Key]: Destination[Key];
+} & Source;
+
/**
Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
@@ -6306,41 +6553,8 @@ declare const SigType: {
*/
declare type Simplify = {[KeyType in keyof T]: T[KeyType]} & {};
-declare const Slash: new () => Operator;
-
-/**
- * Split by operator.
- * @param sep - Separator operator type.
- * @param sequence - A sequence of units.
- * @returns Sub sequences.
- */
-declare function split(sep: typeof T.Operator, sequence: readonly Unit[], { skipEmpty, limit }?: split.Options): Unit[][];
-
-declare namespace split {
- interface Options {
- /**
- * If true, empty sub sequences are skipped.
- * @defaultValue false
- */
- skipEmpty?: boolean;
- /**
- * Maximum number of splits.
- * @remarks
- * `split(Z, "AZBZC", { limit: 1 })` returns `["A", "BZC"]`
- */
- limit?: number;
- }
-}
-
-/** Statement node. */
-declare class Stmt extends Node_2 {
- ident: Ident_2;
- definition: Expr | undefined;
- componentConstraint: ComponentConstraintEq | undefined;
- signingChain: SigningConstraint[];
- constructor(ident: Ident_2, definition?: Expr | undefined, componentConstraint?: ComponentConstraintEq | undefined, signingChain?: SigningConstraint[]);
- toTokens(): Generator;
-}
+/** Convert to a simpler pattern if possible. */
+declare function simplifyPattern(p: Pattern): Pattern;
/**
* KV store where each key is a Name.
@@ -6665,13 +6879,12 @@ declare class Subject extends Observable implements SubscriptionLike {
/**
* Creates a "subject" by basically gluing an observer to an observable.
*
- * @nocollapse
* @deprecated Recommended you do not use. Will be removed at some point in the future. Plans for replacement still under discussion.
*/
static create: (...args: any[]) => any;
constructor();
/** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
- lift(operator: Operator_2): Observable;
+ lift(operator: Operator): Observable;
next(value: T): void;
error(err: any): void;
complete(): void;
@@ -6681,7 +6894,7 @@ declare class Subject extends Observable implements SubscriptionLike {
* Creates a new Observable with this Subject as the source. You can do this
* to create custom Observer-side logic of the Subject and conceal it from
* code that uses the Observable.
- * @return {Observable} Observable that the Subject casts to
+ * @return Observable that this Subject casts to.
*/
asObservable(): Observable;
}
@@ -6703,8 +6916,6 @@ declare interface Subscriber
*/
declare class Subscriber_2 extends Subscription_2 implements Observer {
/**
@@ -6717,7 +6928,6 @@ declare class Subscriber_2 extends Subscription_2 implements Observer {
* Observer.
* @return A Subscriber wrapping the (partially defined)
* Observer represented by the given arguments.
- * @nocollapse
* @deprecated Do not use. Will be removed in v8. There is no replacement for this
* method, and there is no reason to be creating instances of `Subscriber` directly.
* If you have a specific use case, please file an issue.
@@ -6736,23 +6946,20 @@ declare class Subscriber_2 extends Subscription_2 implements Observer {
* The {@link Observer} callback to receive notifications of type `next` from
* the Observable, with a value. The Observable may call this method 0 or more
* times.
- * @param {T} [value] The `next` value.
- * @return {void}
+ * @param value The `next` value.
*/
- next(value?: T): void;
+ next(value: T): void;
/**
* The {@link Observer} callback to receive notifications of type `error` from
* the Observable, with an attached `Error`. Notifies the Observer that
* the Observable has experienced an error condition.
- * @param {any} [err] The `error` exception.
- * @return {void}
+ * @param err The `error` exception.
*/
error(err?: any): void;
/**
* The {@link Observer} callback to receive a valueless notification of type
* `complete` from the Observable. Notifies the Observer that the Observable
* has finished sending push-based notifications.
- * @return {void}
*/
complete(): void;
unsubscribe(): void;
@@ -6789,12 +6996,9 @@ declare namespace Subscription {
* method, which will attach a child Subscription to the current Subscription.
* When a Subscription is unsubscribed, all its children (and its grandchildren)
* will be unsubscribed as well.
- *
- * @class Subscription
*/
declare class Subscription_2 implements SubscriptionLike {
private initialTeardown?;
- /** @nocollapse */
static EMPTY: Subscription_2;
/**
* A flag to indicate whether this Subscription has already been unsubscribed.
@@ -6815,7 +7019,6 @@ declare class Subscription_2 implements SubscriptionLike {
* Disposes the resources held by the subscription. May, for instance, cancel
* an ongoing Observable execution or cancel any other type of work that
* started when the Subscription was created.
- * @return {void}
*/
unsubscribe(): void;
/**
@@ -6921,198 +7124,6 @@ declare namespace SyncProtocol {
};
}
-declare class SyncpsCodec {
- protected readonly ibltParams: IBLT.PreparedParameters;
- constructor(p: SyncpsCodec.Parameters, ibltParams: IBLT.PreparedParameters);
-}
-
-declare interface SyncpsCodec extends Readonly, IbltCodec {
-}
-
-declare namespace SyncpsCodec {
- type Compression = Compression;
- interface Parameters {
- /** Compression method for IBLT in name component. */
- ibltCompression: Compression;
- /** Compute the hash of a publication. */
- hashPub: (pub: Data) => number;
- /** Encode Content to buffer. */
- encodeContent: (pubs: readonly Data[], maxSize: number) => [wire: Uint8Array, count: number];
- /** Decode Content from buffer. */
- decodeContent: (payload: Uint8Array) => Data[];
- }
-}
-
-/** syncps - pubsub service. */
-declare class SyncpsPubsub extends TypedEventTarget implements Subscriber> {
- constructor({ p, syncPrefix, describe, cpOpts, syncInterestLifetime, syncDataPubSize, syncSigner, syncVerifier, maxPubLifetime, maxClockSkew, modifyPublication, isExpired, filterPubs, pubSigner, pubVerifier, }: SyncpsPubsub.Options);
- private readonly maybeHaveEventListener;
- readonly describe: string;
- private readonly syncPrefix;
- private readonly codec;
- private closed;
- private readonly iblt;
- private readonly pubs;
- private readonly maxPubLifetime;
- private readonly maxClockSkew;
- private readonly subs;
- private readonly dModify;
- private readonly dIsExpired;
- private readonly dSigner;
- private readonly dVerifier?;
- private nOwnPubs;
- /** IBLT of own publications with callback. */
- private readonly dConfirmIblt;
- private readonly pProducer;
- private readonly pFilter;
- private readonly pPubSize;
- private readonly pPendings;
- private readonly cOpts;
- private readonly cLifetime;
- private cAbort?;
- private cTimer;
- private cCurrentInterestNonce?;
- private cDelivering;
- private debug;
- /** Stop the protocol operation. */
- close(): void;
- /**
- * Publish a packet.
- * @param pub - Data packet. This does not need to be signed.
- * @param cb - Callback to get notified whether publication is confirmed,
- * i.e. its hash appears in a sync Interest from another participant.
- * @returns - Promise that resolves when the publication is recorded.
- * It does not mean the publication has reached other participants.
- */
- publish(pub: Data, cb?: SyncpsPubsub.PublishCallback): Promise;
- /** Subscribe to a topic. */
- subscribe(topic: Name): Subscription>;
- private handleSyncInterest;
- private processSyncInterest;
- private processPendingInterests;
- private scheduleSyncInterest;
- private sendSyncInterest;
- private isExpired;
- private addToActive;
- private invokePublishCb;
-}
-
-declare namespace SyncpsPubsub {
- interface Parameters extends SyncpsCodec.Parameters {
- iblt: IBLT.Parameters;
- }
- type ModifyPublicationCallback = (pub: Data) => void;
- /**
- * Callback to determine if a publication is expired.
- *
- * @remarks
- * The callback can return either:
- * - boolean to indicate whether the publication is expired.
- * - number, interpreted as Unix timestamp (milliseconds) of publication creation time.
- * The publication is considered expired if this timestamp is before
- * `NOW - (maxPubLifetime+maxClockSkew)` or after `NOW + maxClockSkew`.
- */
- type IsExpiredCallback = (pub: Data) => boolean | number;
- interface FilterPubItem {
- /** A publication, i.e. Data packet. */
- readonly pub: Data;
- /** Whether the publication is owned by the local participant. */
- readonly own: boolean;
- }
- /**
- * Callback to decide what publications to be included in a response.
- * @param items - Unexpired publications.
- * @returns A priority list of publications to be included in the response.
- */
- type FilterPubsCallback = (items: FilterPubItem[]) => FilterPubItem[];
- interface Options {
- /**
- * Algorithm parameters.
- *
- * @remarks
- * They must be the same on every peer.
- */
- p: Parameters;
- /** Sync group prefix. */
- syncPrefix: Name;
- /**
- * Description for debugging purpose.
- * @defaultValue SyncpsPubsub + syncPrefix
- */
- describe?: string;
- /**
- * Consumer and producer options.
- *
- * @remarks
- * - `.fw` may be specified.
- * - Most other fields are overridden.
- */
- cpOpts?: ConsumerOptions & ProducerOptions;
- /**
- * Sync Interest lifetime in milliseconds.
- * @defaultValue 4000
- */
- syncInterestLifetime?: number;
- /**
- * Advisory maximum size for publications included in a sync reply Data packet.
- * @defaultValue 1300
- */
- syncDataPubSize?: number;
- /**
- * Signer of sync reply Data packets.
- * @defaultValue digestSigning
- */
- syncSigner?: Signer;
- /**
- * Verifier of sync reply Data packets.
- * @defaultValue no verification
- */
- syncVerifier?: Verifier;
- /**
- * Publication lifetime.
- * @defaultValue 1000
- */
- maxPubLifetime?: number;
- /**
- * Maximum clock skew, for calculating timers.
- * @defaultValue 1000
- */
- maxClockSkew?: number;
- /**
- * Callback to modify publication before it's signed.
- * @defaultValue appending a TimestampNameComponent to the name
- */
- modifyPublication?: ModifyPublicationCallback;
- /**
- * Callback to determine if a publication is expired.
- *
- * @defaultValue
- * The last component is interpreted as TimestampNameComponent.
- * If it is not a TimestampNameComponent, the publication is seen as expired.
- */
- isExpired?: IsExpiredCallback;
- /**
- * Callback to decide what publications to be included in a response.
- *
- * @defaultValue
- * - Respond nothing if there's no own publication.
- * - Otherwise, prioritize own publications over others, and prioritize later timestamp.
- */
- filterPubs?: FilterPubsCallback;
- /**
- * Signer of publications.
- * @defaultValue digestSigning
- */
- pubSigner?: Signer;
- /**
- * Verifier of publications.
- * @defaultValue no verification
- */
- pubVerifier?: Verifier;
- }
- type PublishCallback = (pub: Data, confirmed: boolean) => void;
-}
-
/** A received update regarding a node. */
declare class SyncUpdate