surgio 2.25.2 → 3.0.0-alpha.0

package/build/generator/artifact.d.ts

@@ -3,15 +3,13 @@ import _ from 'lodash';
 import { Environment } from 'nunjucks';
 import { EventEmitter } from 'events';
 import { getProvider } from '../provider';
-import { ArtifactConfig, CommandConfig, PossibleNodeConfigType, RemoteSnippet, SimpleNodeConfig } from '../types';
-declare type ThenArg<T> = T extends PromiseLike<infer U> ? U : T;
+import { GetNodeListParams } from '../provider/types';
+import { ArtifactConfig, CommandConfig, PossibleNodeConfigType, RemoteSnippet, ThenArg } from '../types';
 export interface ArtifactOptions {
     readonly remoteSnippetList?: ReadonlyArray<RemoteSnippet>;
     readonly templateEngine?: Environment;
 }
-export interface ExtendableRenderContext {
-    readonly urlParams?: Record<string, string>;
-}
+export type ExtendableRenderContext = Record<string, string>;
 export declare class Artifact extends EventEmitter {
     surgioConfig: CommandConfig;
     artifact: ArtifactConfig;
@@ -21,73 +19,310 @@ export declare class Artifact extends EventEmitter {
     nodeConfigListMap: Map<string, ReadonlyArray<PossibleNodeConfigType>>;
     providerMap: Map<string, ThenArg<ReturnType<typeof getProvider>>>;
     nodeList: PossibleNodeConfigType[];
-    nodeNameList: SimpleNodeConfig[];
     private customFilters;
     private netflixFilter;
     private youtubePremiumFilter;
     constructor(surgioConfig: CommandConfig, artifact: ArtifactConfig, options?: ArtifactOptions);
     get isReady(): boolean;
     getRenderContext(extendRenderContext?: ExtendableRenderContext): {
-        clashProxyConfig?: {
-            proxies: readonly any[];
-            'proxy-groups': readonly any[];
-        } | undefined;
-        proxyTestUrl: string | undefined;
-        downloadUrl: string;
-        snippet: (filePath: string) => RemoteSnippet;
-        nodes: PossibleNodeConfigType[];
-        names: SimpleNodeConfig[];
-        remoteSnippets: _.Dictionary<RemoteSnippet>;
-        nodeList: PossibleNodeConfigType[];
-        provider: string;
-        providerName: string;
-        artifactName: string;
-        getDownloadUrl: (name: string) => string;
-        getUrl: (p: string) => string;
-        getNodeNames: (list: readonly SimpleNodeConfig[], filter?: import("../types").SortedNodeNameFilterType | import("../types").NodeNameFilterType | undefined, separator?: string | undefined) => string;
-        getClashNodeNames: (list: readonly SimpleNodeConfig[], filter?: import("../types").SortedNodeNameFilterType | import("../types").NodeNameFilterType | undefined, existingProxies?: readonly string[] | undefined) => readonly string[];
-        getClashNodes: (list: readonly PossibleNodeConfigType[], filter?: import("../types").SortedNodeNameFilterType | import("../types").NodeFilterType | undefined) => readonly any[];
-        getSurgeNodes: (list: readonly PossibleNodeConfigType[], filter?: import("../types").SortedNodeNameFilterType | import("../types").NodeFilterType | undefined) => string;
-        getSurfboardNodes: (list: readonly PossibleNodeConfigType[], filter?: import("../types").SortedNodeNameFilterType | import("../types").NodeFilterType | undefined) => string;
-        getShadowsocksNodes: (list: readonly import("../types").ShadowsocksNodeConfig[], groupName?: string) => string;
-        getShadowsocksNodesJSON: (list: readonly import("../types").ShadowsocksNodeConfig[]) => string;
-        getShadowsocksrNodes: (list: readonly import("../types").ShadowsocksrNodeConfig[], groupName: string) => string;
-        getQuantumultNodes: (list: readonly (import("../types").VmessNodeConfig | import("../types").HttpsNodeConfig | import("../types").ShadowsocksNodeConfig | import("../types").ShadowsocksrNodeConfig)[], groupName?: string, filter?: import("../types").SortedNodeNameFilterType | import("../types").NodeNameFilterType | undefined) => string;
-        getV2rayNNodes: (list: readonly import("../types").VmessNodeConfig[]) => string;
-        getQuantumultXNodes: (list: readonly PossibleNodeConfigType[], filter?: import("../types").SortedNodeNameFilterType | import("../types").NodeNameFilterType | undefined) => string;
-        getMellowNodes: (list: readonly (import("../types").VmessNodeConfig | import("../types").ShadowsocksNodeConfig)[], filter?: import("../types").SortedNodeNameFilterType | import("../types").NodeFilterType | undefined) => string;
-        getLoonNodes: (list: readonly PossibleNodeConfigType[], filter?: import("../types").SortedNodeNameFilterType | import("../types").NodeNameFilterType | undefined) => string;
-        usFilter: import("../types").NodeNameFilterType;
-        hkFilter: import("../types").NodeNameFilterType;
-        japanFilter: import("../types").NodeNameFilterType;
-        koreaFilter: import("../types").NodeNameFilterType;
-        singaporeFilter: import("../types").NodeNameFilterType;
-        taiwanFilter: import("../types").NodeNameFilterType;
-        chinaBackFilter: import("../types").NodeNameFilterType;
-        chinaOutFilter: import("../types").NodeNameFilterType;
-        shadowsocksFilter: import("../types").NodeNameFilterType;
-        shadowsocksrFilter: import("../types").NodeNameFilterType;
-        vmessFilter: import("../types").NodeNameFilterType;
-        v2rayFilter: import("../types").NodeNameFilterType;
-        snellFilter: import("../types").NodeNameFilterType;
-        httpFilter: import("../types").NodeNameFilterType;
-        httpsFilter: import("../types").NodeNameFilterType;
-        trojanFilter: import("../types").NodeNameFilterType;
-        socks5Filter: import("../types").NodeNameFilterType;
-        toUrlSafeBase64: (str: string) => string;
-        toBase64: (str: string) => string;
-        encodeURIComponent: typeof encodeURIComponent;
-        netflixFilter: NonNullable<import("../types").SortedNodeNameFilterType | import("../types").NodeNameFilterType | undefined>;
-        youtubePremiumFilter: NonNullable<import("../types").SortedNodeNameFilterType | import("../types").NodeNameFilterType | undefined>;
-        customFilters: {
-            readonly [name: string]: import("../types").SortedNodeNameFilterType | import("../types").NodeNameFilterType;
-        };
-        customParams: import("../types").PlainObjectOf<string | number | boolean> & Record<string, string>;
+        readonly proxyTestUrl: string | undefined;
+        readonly internetTestUrl: string | undefined;
+        readonly downloadUrl: string;
+        readonly snippet: (filePath: string) => RemoteSnippet;
+        readonly remoteSnippets: _.Dictionary<RemoteSnippet>;
+        readonly nodeList: PossibleNodeConfigType[];
+        readonly provider: string;
+        readonly providerName: string;
+        readonly artifactName: string;
+        readonly getDownloadUrl: (name: string) => string;
+        readonly getUrl: (p: string) => string;
+        readonly getNodeNames: (list: readonly PossibleNodeConfigType[], filter?: ((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        } | undefined, separator?: string | undefined) => string;
+        readonly getClashNodes: (list: readonly PossibleNodeConfigType[], filter?: ((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        } | undefined) => NonNullable<{
+            plugin?: string | undefined;
+            readonly 'client-fingerprint'?: string | undefined;
+            'plugin-opts'?: {
+                mode: "tls" | "http" | "ws" | "wss";
+                host: string | undefined;
+            } | {
+                host: string | undefined;
+                path: string;
+                mux: boolean;
+                headers: _.Omit<Record<string, string>, "host">;
+                'skip-cert-verify'?: boolean | undefined;
+                mode: string;
+                tls: boolean;
+            } | {
+                host?: string | undefined;
+                version?: number | undefined;
+                password: string;
+                mode?: undefined;
+            } | undefined;
+            readonly type: "ss";
+            readonly cipher: string;
+            readonly name: string;
+            readonly password: string;
+            readonly port: string | number;
+            readonly server: string;
+            readonly udp: boolean;
+            readonly obfs?: undefined;
+            readonly protocol?: undefined;
+            readonly 'obfs-param'?: undefined;
+            readonly 'protocol-param'?: undefined;
+            readonly username?: undefined;
+            readonly tls?: undefined;
+            readonly 'skip-cert-verify'?: undefined;
+        } | {
+            readonly 'ws-opts'?: {
+                path: string | undefined;
+                headers: {
+                    host?: string | undefined;
+                };
+            } | undefined;
+            readonly 'skip-cert-verify'?: boolean | undefined;
+            readonly tls: boolean;
+            readonly network?: "ws" | undefined;
+            readonly type: "vmess";
+            readonly cipher: "none" | "aes-128-gcm" | "chacha20-ietf-poly1305" | "auto";
+            readonly name: string;
+            readonly server: string;
+            readonly port: string | number;
+            readonly udp: boolean;
+            readonly uuid: string;
+            readonly alterId: string;
+            readonly password?: undefined;
+            readonly obfs?: undefined;
+            readonly protocol?: undefined;
+            readonly 'obfs-param'?: undefined;
+            readonly 'protocol-param'?: undefined;
+            readonly username?: undefined;
+        } | {
+            readonly type: "ssr";
+            readonly name: string;
+            readonly server: string;
+            readonly port: string | number;
+            readonly password: string;
+            readonly obfs: string;
+            readonly protocol: string;
+            readonly cipher: string;
+            readonly 'obfs-param': string;
+            readonly 'protocol-param': string;
+            readonly udp: boolean;
+            readonly username?: undefined;
+            readonly tls?: undefined;
+            readonly 'skip-cert-verify'?: undefined;
+        } | {
+            readonly version?: string | number | undefined;
+            readonly type: "snell";
+            readonly name: string;
+            readonly server: string;
+            readonly port: string | number;
+            readonly psk: string;
+            readonly 'obfs-opts': {
+                readonly host?: string | undefined;
+                readonly mode: "tls" | "http" | undefined;
+            };
+            readonly password?: undefined;
+            readonly obfs?: undefined;
+            readonly protocol?: undefined;
+            readonly cipher?: undefined;
+            readonly 'obfs-param'?: undefined;
+            readonly 'protocol-param'?: undefined;
+            readonly udp?: undefined;
+            readonly username?: undefined;
+            readonly tls?: undefined;
+            readonly 'skip-cert-verify'?: undefined;
+        } | {
+            readonly type: "http";
+            readonly name: string;
+            readonly server: string;
+            readonly port: string | number;
+            readonly username: string;
+            readonly password: string;
+            readonly tls: true;
+            readonly 'skip-cert-verify': boolean;
+            readonly obfs?: undefined;
+            readonly protocol?: undefined;
+            readonly cipher?: undefined;
+            readonly 'obfs-param'?: undefined;
+            readonly 'protocol-param'?: undefined;
+            readonly udp?: undefined;
+        } | {
+            readonly type: "http";
+            readonly name: string;
+            readonly server: string;
+            readonly port: string | number;
+            readonly username: string;
+            readonly password: string;
+            readonly obfs?: undefined;
+            readonly protocol?: undefined;
+            readonly cipher?: undefined;
+            readonly 'obfs-param'?: undefined;
+            readonly 'protocol-param'?: undefined;
+            readonly udp?: undefined;
+            readonly tls?: undefined;
+            readonly 'skip-cert-verify'?: undefined;
+        } | {
+            readonly network?: string | undefined;
+            readonly 'ws-opts'?: {
+                path: string;
+                headers?: undefined;
+            } | undefined;
+            readonly 'skip-cert-verify': boolean;
+            readonly sni?: string | undefined;
+            readonly alpn?: [string, ...string[]] | undefined;
+            readonly udp?: true | undefined;
+            readonly type: "trojan";
+            readonly name: string;
+            readonly server: string;
+            readonly port: string | number;
+            readonly password: string;
+            readonly obfs?: undefined;
+            readonly protocol?: undefined;
+            readonly cipher?: undefined;
+            readonly 'obfs-param'?: undefined;
+            readonly 'protocol-param'?: undefined;
+            readonly username?: undefined;
+            readonly tls?: undefined;
+        } | {
+            readonly udp?: boolean | undefined;
+            readonly 'skip-cert-verify'?: boolean | undefined;
+            readonly tls?: boolean | undefined;
+            readonly password?: string | undefined;
+            readonly username?: string | undefined;
+            readonly type: "socks5";
+            readonly name: string;
+            readonly server: string;
+            readonly port: string | number;
+            readonly obfs?: undefined;
+            readonly protocol?: undefined;
+            readonly cipher?: undefined;
+            readonly 'obfs-param'?: undefined;
+            readonly 'protocol-param'?: undefined;
+        } | {
+            readonly alpn?: [string, ...string[]] | undefined;
+            readonly type: "tuic";
+            readonly name: string;
+            readonly server: string;
+            readonly port: string | number;
+            readonly udp: true;
+            readonly password?: undefined;
+            readonly obfs?: undefined;
+            readonly protocol?: undefined;
+            readonly cipher?: undefined;
+            readonly 'obfs-param'?: undefined;
+            readonly 'protocol-param'?: undefined;
+            readonly username?: undefined;
+            readonly tls?: undefined;
+            readonly 'skip-cert-verify'?: undefined;
+        } | {
+            readonly reserved?: number[] | undefined;
+            readonly 'preshared-key'?: string | undefined;
+            readonly udp: true;
+            readonly server: string;
+            readonly port: number;
+            readonly 'public-key': string;
+            readonly dns?: [string, ...string[]] | undefined;
+            readonly mtu?: number | undefined;
+            readonly ipv6?: string | undefined;
+            readonly type: "wireguard";
+            readonly name: string;
+            readonly 'private-key': string;
+            readonly ip: string;
+            readonly password?: undefined;
+            readonly obfs?: undefined;
+            readonly protocol?: undefined;
+            readonly cipher?: undefined;
+            readonly 'obfs-param'?: undefined;
+            readonly 'protocol-param'?: undefined;
+            readonly username?: undefined;
+            readonly tls?: undefined;
+            readonly 'skip-cert-verify'?: undefined;
+        } | null>[];
+        readonly getClashNodeNames: (list: readonly PossibleNodeConfigType[], filter?: ((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        } | undefined, prependNodeNames?: readonly string[] | undefined) => readonly string[];
+        readonly getSurgeNodes: (nodeList: readonly PossibleNodeConfigType[], filter?: ((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        } | undefined) => string;
+        readonly getSurgeNodeNames: (nodeList: readonly PossibleNodeConfigType[], filter?: ((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        } | undefined) => string;
+        readonly getSurgeWireguardNodes: (nodeList: readonly PossibleNodeConfigType[]) => string;
+        readonly getSurfboardNodes: (list: readonly PossibleNodeConfigType[], filter?: ((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        } | undefined) => string;
+        readonly getSurfboardNodeNames: (list: readonly PossibleNodeConfigType[], filter?: ((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        } | undefined) => string;
+        readonly getShadowsocksNodes: (list: readonly import("../types").ShadowsocksNodeConfig[], groupName?: string) => string;
+        readonly getShadowsocksNodesJSON: (list: readonly import("../types").ShadowsocksNodeConfig[]) => string;
+        readonly getShadowsocksrNodes: (list: readonly import("../types").ShadowsocksrNodeConfig[], groupName: string) => string;
+        readonly getV2rayNNodes: (list: readonly import("../types").VmessNodeConfig[]) => string;
+        readonly getQuantumultXNodes: (nodeList: readonly PossibleNodeConfigType[], filter?: ((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        } | undefined) => string;
+        readonly getQuantumultXNodeNames: (nodeList: readonly PossibleNodeConfigType[], filter?: ((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        } | undefined) => string;
+        readonly getLoonNodes: (list: readonly PossibleNodeConfigType[], filter?: ((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        } | undefined) => string;
+        readonly getLoonNodeNames: (list: readonly PossibleNodeConfigType[], filter?: ((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        } | undefined, separator?: string | undefined) => string;
+        readonly usFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly hkFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly japanFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly koreaFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly singaporeFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly taiwanFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly chinaBackFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly chinaOutFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly shadowsocksFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly shadowsocksrFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly vmessFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly v2rayFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly snellFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly httpFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly httpsFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly trojanFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly socks5Filter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly wireguardFilter: (nodeConfig: PossibleNodeConfigType) => boolean;
+        readonly toUrlSafeBase64: (str: string) => string;
+        readonly toBase64: (str: string) => string;
+        readonly encodeURIComponent: typeof encodeURIComponent;
+        readonly netflixFilter: NonNullable<((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        } | undefined>;
+        readonly youtubePremiumFilter: NonNullable<((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        } | undefined>;
+        readonly customFilters: Record<string, ((nodeConfig: PossibleNodeConfigType) => boolean) | {
+            readonly filter: <T extends PossibleNodeConfigType>(nodeList: readonly T[]) => readonly T[];
+            readonly supportSort: true;
+        }>;
+        readonly customParams: Record<string, unknown> & ExtendableRenderContext;
     };
-    init({ requestUserAgent, }?: {
-        requestUserAgent?: string;
+    init(params?: {
+        getNodeListParams?: GetNodeListParams;
     }): Promise<this>;
     render(templateEngine?: Environment, extendRenderContext?: ExtendableRenderContext): string;
     private providerMapper;
 }
-export {};