@types/urijs

Version 1.19.26
Published 26 days ago
15.7 kB
No dependencies
MIT license

Install

npm i @types/urijs

yarn add @types/urijs

pnpm add @types/urijs

Overview

TypeScript definitions for urijs

Index

Variables

Variables

variable URI

const URI: {
    (value?: string | URI.URIOptions | HTMLElement, base?: string | URI): URI;
    new (value?: string | URI.URIOptions | HTMLElement, base?: string | URI): URI;
    addQuery(data: URI.QueryDataMap, prop: string, value: string): object;
    addQuery(data: URI.QueryDataMap, qryObj: object): object;
    build(parts: URI.URIOptions): string;
    buildAuthority(parts: {
        username?: string | undefined;
        password?: string | undefined;
        hostname?: string | undefined;
        port?: string | undefined;
    }): string;
    buildHost(parts: {
        hostname?: string | undefined;
        port?: string | undefined;
    }): string;
    buildQuery(
        data: URI.QueryDataMap,
        duplicateQueryParameters?: boolean,
        escapeQuerySpace?: boolean
    ): string;
    buildUserinfo(parts: {
        username?: string | undefined;
        password?: string | undefined;
    }): string;
    commonPath(path1: string, path2: string): string;
    decode(str: string): string;
    decodeQuery(qry: string): string;
    duplicateQueryParameters: boolean;
    encode(str: string): string;
    encodeQuery(qry: string): string;
    encodeReserved(str: string): string;
    escapeQuerySpace: boolean;
    expand?: (template: string, vals: object) => string;
    iso8859(): void;
    joinPaths(...paths: Array<string | URI>): URI;
    parse(url: string): URI.Parts;
    parseAuthority(
        url: string,
        parts: {
            username?: string | undefined;
            password?: string | undefined;
            hostname?: string | undefined;
            port?: string | undefined;
        }
    ): string;
    parseHost(
        url: string,
        parts: { hostname?: string | undefined; port?: string | undefined }
    ): string;
    parseQuery(url: string): URI.QueryDataMap;
    parseUserinfo(
        url: string,
        parts: { username?: string | undefined; password?: string | undefined }
    ): string;
    preventInvalidHostname: boolean;
    removeQuery(data: object, prop: string, value: string): object;
    removeQuery(data: object, props: string[] | object): object;
    unicode(): void;
    withinString(
        source: string,
        func: (url: string, start: number, end: number, source: string) => string
    ): string;
};

Interfaces

interface Parts

interface Parts extends URIOptions {}

property duplicateQueryParameters

duplicateQueryParameters: boolean;

property escapeQuerySpace

escapeQuerySpace: boolean;

property preventInvalidHostname

preventInvalidHostname: boolean;

interface ReadonlyURI

interface ReadonlyURI {}

method authority

authority: () => string;

method clone

clone: () => URI;

method directory

directory: (dir?: boolean) => string;

method domain

domain: (domain?: boolean) => string;

method equals

equals: (url?: string | ReadonlyURI | URI) => boolean;

method filename

filename: (file?: boolean) => string;

method fragment

fragment: () => string;

method hash

hash: () => string;

method hasQuery

hasQuery: (
    name: any,
    value?:
        | string
        | number
        | boolean
        | RegExp
        | string[]
        | number[]
        | boolean[]
        | ((...args: any[]) => any),
    withinArray?: boolean
) => boolean;

method hasSearch

hasSearch: (
    name: any,
    value?:
        | string
        | number
        | boolean
        | RegExp
        | string[]
        | number[]
        | boolean[]
        | ((...args: any[]) => any),
    withinArray?: boolean
) => boolean;

method host

host: () => string;

method hostname

hostname: () => string;

method href

href: () => string;

method is

is: (
    qry:
        | 'relative'
        | 'absolute'
        | 'urn'
        | 'url'
        | 'domain'
        | 'name'
        | 'sld'
        | 'idn'
        | 'punycode'
        | 'ip'
        | 'ip4'
        | 'ipv4'
        | 'inet4'
        | 'ip6'
        | 'ipv6'
        | 'inet6'
) => boolean;

method origin

origin: () => string;

method password

password: () => string;

method path

path: (path?: boolean) => string;

method pathname

pathname: (path?: boolean) => string;

method port

port: () => string;

method protocol

protocol: () => string;

method query

query: { (): string; (v: boolean): Partial<Record<string, any>> };

method readable

readable: () => string;

method resource

resource: () => string;

method scheme

scheme: () => string;

method search

search: { (): string; (v: boolean): Partial<Record<string, any>> };

method segment

segment: { (): string[]; (position: number): string };

method segmentCoded

segmentCoded: { (): string[]; (position: number): string };

method subdomain

subdomain: () => string;

method suffix

suffix: (suffix?: boolean) => string;

method tld

tld: (tld?: boolean) => string;

method userinfo

userinfo: () => string;

method username

username: () => string;

method valueOf

valueOf: () => string;

interface URI

interface URI {}

method absoluteTo

absoluteTo: (path: string | URI) => URI;

method addFragment

addFragment: (fragment: string) => URI;

method addQuery

addQuery: {
    (qry: string | URI.QueryDataMap): URI;
    (qry: string, value: any): URI;
};

method addSearch

addSearch: {
    (qry: string | URI.QueryDataMap): URI;
    (key: string, value: any): URI;
};

method authority

authority: { (): string; (authority: string): URI };

method clone

clone: () => URI;

method directory

directory: { (dir?: boolean): string; (dir: string): URI };

method domain

domain: { (domain?: boolean): string; (domain: string): URI };

method duplicateQueryParameters

duplicateQueryParameters: (val: boolean) => URI;

method equals

equals: (url?: string | URI) => boolean;

method escapeQuerySpace

escapeQuerySpace: (val: boolean) => URI;

method filename

filename: { (file?: boolean): string; (file: string): URI };

method fragment

fragment: { (): string; (fragment: string): URI };

method fragmentPrefix

fragmentPrefix: (prefix: string) => URI;

method hash

hash: { (): string; (hash: string): URI };

method hasQuery

hasQuery: (
    name: any,
    value?:
        | string
        | number
        | boolean
        | RegExp
        | string[]
        | number[]
        | boolean[]
        | ((...args: any[]) => any),
    withinArray?: boolean
) => boolean;

method hasSearch

hasSearch: (
    name: any,
    value?:
        | string
        | number
        | boolean
        | RegExp
        | string[]
        | number[]
        | boolean[]
        | ((...args: any[]) => any),
    withinArray?: boolean
) => boolean;

method host

host: { (): string; (host: string): URI };

method hostname

hostname: { (): string; (hostname: string): URI };

method href

href: { (): string; (url: string): void };

method is

is: (
    qry:
        | 'relative'
        | 'absolute'
        | 'urn'
        | 'url'
        | 'domain'
        | 'name'
        | 'sld'
        | 'idn'
        | 'punycode'
        | 'ip'
        | 'ip4'
        | 'ipv4'
        | 'inet4'
        | 'ip6'
        | 'ipv6'
        | 'inet6'
) => boolean;

method iso8859

iso8859: () => URI;

method normalize

normalize: () => URI;

method normalizeFragment

normalizeFragment: () => URI;

method normalizeHash

normalizeHash: () => URI;

method normalizeHostname

normalizeHostname: () => URI;

method normalizePath

normalizePath: () => URI;

method normalizePathname

normalizePathname: () => URI;

method normalizePort

normalizePort: () => URI;

method normalizeProtocol

normalizeProtocol: () => URI;

method normalizeQuery

normalizeQuery: () => URI;

method normalizeSearch

normalizeSearch: () => URI;

method origin

origin: { (): string; (uri: string | URI): URI };

method password

password: { (): string; (pw: string): URI };

method path

path: { (path?: boolean): string; (path: string): URI };

method pathname

pathname: { (path?: boolean): string; (path: string): URI };

method port

port: { (): string; (port: string): URI };

method preventInvalidHostname

preventInvalidHostname: (val: boolean) => URI;

method protocol

protocol: { (): string; (protocol: string): URI };

method query

query: {
    (): string;
    (
        qry:
            | string
            | Partial<Record<string, any>>
            | ((
                  qryObject: Partial<Record<string, any>>
              ) => void | Partial<Record<string, any>>)
    ): URI;
    (v: boolean): Partial<Record<string, any>>;
};

method readable

readable: () => string;

method relativeTo

relativeTo: (path: string) => URI;

method removeQuery

removeQuery: {
    (qry: string | URI.QueryDataMap): URI;
    (name: string, value: string): URI;
};

method removeSearch

removeSearch: {
    (qry: string | URI.QueryDataMap): URI;
    (name: string, value: string): URI;
};

method resource

resource: { (): string; (resource: string): URI };

method scheme

scheme: { (): string; (protocol: string): URI };

method search

search: {
    (): string;
    (
        qry:
            | string
            | Partial<Record<string, any>>
            | ((
                  qryObject: Partial<Record<string, any>>
              ) => void | Partial<Record<string, any>>)
    ): URI;
    (v: boolean): Partial<Record<string, any>>;
};

method segment

segment: {
    (): string[];
    (segments: string | string[]): URI;
    (position: number): string;
    (position: number, level: string): URI;
};

method segmentCoded

segmentCoded: {
    (): string[];
    (segments: string | string[]): URI;
    (position: number): string;
    (position: number, level: string): URI;
};

method setQuery

setQuery: {
    (key: string, value: any): URI;
    (qry: Partial<Record<string, any>>): URI;
};

method setSearch

setSearch: {
    (key: string, value: any): URI;
    (qry: Partial<Record<string, any>>): URI;
};

method subdomain

subdomain: { (): string; (subdomain: string): URI };

method suffix

suffix: { (suffix?: boolean): string; (suffix: string): URI };

method tld

tld: { (tld?: boolean): string; (tld: string): URI };

method unicode

unicode: () => URI;

method userinfo

userinfo: { (): string; (userinfo: string): URI };

method username

username: { (): string; (uname: string): URI };

method valueOf

valueOf: () => string;

interface URIOptions

interface URIOptions {}

property fragment

fragment?: string | undefined;

property hostname

hostname?: string | undefined;

property password

password?: string | undefined;

property path

path?: string | undefined;

property port

port?: string | undefined;

property protocol

protocol?: string | undefined;

property query

query?: string | undefined;

property urn

urn?: boolean | undefined;

property username

username?: string | undefined;

Type Aliases

type QueryDataMap

type QueryDataMap = Partial<Record<string, any>>;

Namespaces

namespace global

namespace global {}

interface JQuery

interface JQuery {}

method uri

uri: () => URI;

Package Files (1)

index.d.ts

Dependencies (0)

No dependencies.

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/urijs.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/urijs)

HTML

<a href="https://www.jsdocs.io/package/@types/urijs"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 22 days ago.
Package analyzed in 2266 ms.
Missing or incorrect documentation? Open an issue for this package.