@chilkat/react-native 11.6.1 → 11.7.0

package/src/specs/Socket.nitro.ts

@@ -216,6 +216,15 @@ export interface Socket extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    *
    * | 125 |  | An SSL 2.0 connection attempt was received and rejected. |
    *
+   * | 129 | | The client and server share no ALPN protocol. (Added in 11.7.0. See `AlpnProtocols`.)
+   * |
+   *
+   * | 130 | | The client's SNI hostname matched no server certificate and `RequireSniMatch` is set.
+   * (Added in 11.7.0.) |
+   *
+   * | 131 | | The client offered a session ticket for a session that used the extended master
+   * secret, but its ClientHello did not offer that extension. (Added in 11.7.0.) |
+   *
    * This property is read-only.
    */
   readonly acceptFailReason: number
@@ -1252,8 +1261,23 @@ export interface Socket extends HybridObject<{ ios: 'c++', android: 'c++' }> {
   uncommonOptions: string
 
   /**
-   * Specifies the application-layer protocol name offered in the TLS ALPN extension, such as `h2`
-   * or `http/1.1`. Leave it empty when ALPN is not required.
+   * A single application-layer protocol name for the TLS ALPN extension, such as `h2` or
+   * `http/1.1`. Leave it empty when ALPN is not required.
+   *
+   * Setting this property sets the ALPN list to this one protocol, replacing anything previously
+   * set by it or by `AlpnProtocols`. Setting an empty string clears the list. To offer or support
+   * more than one protocol, use `AlpnProtocols` instead.
+   *
+   * Getting this property returns the protocol that was negotiated for the connection. Before a
+   * handshake has completed, and on a connection where ALPN was not negotiated, it returns the
+   * first protocol in the ALPN list, which for an application that set a single protocol is the
+   * protocol it set.
+   *
+   * **Changed in 11.7.0:** After a handshake this property returns the negotiated protocol rather
+   * than the configured one. For a connection that negotiated the protocol that was set – which is
+   * every case prior to 11.7.0, because only one protocol could be offered – the value is
+   * unchanged. Prior to 11.7.0 a TLS server ignored ALPN entirely, and a TLS client could offer
+   * only one protocol.
    *
    * **Note:** ALPN negotiation does not implement the selected application protocol. The
    * application must still speak that protocol over the established TLS connection.
@@ -1268,6 +1292,10 @@ export interface Socket extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    *
    * **Scope:** This property changes only the SNI name in the TLS handshake. It does not change the
    * DNS lookup, TCP destination, or any hostname carried by the application protocol.
+   *
+   * **Added in 11.7.0 – server side:** On the socket returned by `AcceptNext`, this property is the
+   * hostname the client asked for, or empty if the client sent no SNI. Use `AddSslServerCert` to
+   * present a different certificate per hostname.
    */
   sniHostname: string
 
@@ -1284,6 +1312,77 @@ export interface Socket extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    */
   readonly numBytesAvailable: number
 
+  /**
+   * The list of ALPN (Application-Layer Protocol Negotiation) protocols, in preference order, as
+   * JSON. On a TLS client this is the set of protocols offered. On a TLS listener it is the set of
+   * protocols the server supports.
+   *
+   * Setting this property accepts either a JSON array, such as `["h2","http/1.1"]`, or a JSON
+   * object with a `protocols` member, such as `{"protocols":["h2","http/1.1"]}`. Setting an empty
+   * string clears the list. Getting this property returns the object form, so a value read from it
+   * can be passed back to it unchanged.
+   *
+   * This property and `AlpnProtocol` address the same underlying list. Setting `AlpnProtocol`
+   * replaces the list with that single protocol id, and setting this property replaces the whole
+   * list. An application normally uses one or the other.
+   *
+   * An object that leaves the list empty does not use ALPN at all.
+   *
+   * **Server behavior when nothing matches:** A TLS server that sets this list and shares no
+   * protocol with the client refuses the connection with the `no_application_protocol` alert, as
+   * RFC 7301 requires, and `AcceptFailReason` is set to 129. A server that leaves the list empty
+   * ignores ALPN and accepts the connection.
+   *
+   * **Note:** ALPN negotiation does not implement the selected application protocol. The
+   * application must still speak that protocol over the established TLS connection.
+   */
+  alpnProtocols: string
+
+  /**
+   * Controls what a TLS server does when the client's SNI (Server Name Indication) hostname matches
+   * no certificate added by `AddSslServerCert`. The default is `false`.
+   *
+   * When `false`, the connection is served the default certificate, which is the one passed to
+   * `InitSslServer`. When `true`, the handshake is refused with the `unrecognized_name` alert and
+   * `AcceptFailReason` is set to 130.
+   *
+   * **Applies to the listener:** Set this property on the listening socket before `AcceptNext`. It
+   * has no effect on a client-side connection.
+   */
+  requireSniMatch: boolean
+
+  /**
+   * The number of seconds a session ticket issued by this TLS server remains valid. The default is
+   * `7200` (2 hours). The maximum is `604800` (7 days, the limit set by RFC 8446); a larger value
+   * is reduced to that maximum. Set it to `0` to issue no tickets, which disables session
+   * resumption for this server.
+   *
+   * Applies to both TLS 1.2 session tickets (RFC 5077) and TLS 1.3 session tickets (RFC 8446). A
+   * resuming client skips the certificate exchange and the server's signature, so a resumed
+   * handshake is both smaller and faster than a full one.
+   *
+   * **No configuration required:** A random ticket key is generated automatically, so resumption
+   * works for the life of a listener without calling `SetTlsTicketKey`. That method is only needed
+   * when tickets must stay valid across processes or restarts.
+   */
+  tlsTicketLifetimeSeconds: number
+
+  /**
+   * Returns `true` when this connection was resumed from a session ticket instead of being fully
+   * handshaked; otherwise returns `false`.
+   *
+   * Read it on the socket returned by `AcceptNext` for a server-side connection, or after `Connect`
+   * for a client-side connection. It applies to both TLS 1.2 and TLS 1.3 resumption.
+   *
+   * **A resumed connection exchanges no certificates:** Neither side sends a Certificate message
+   * when the session is resumed. On the server, the client certificate from the original handshake
+   * is restored, so `GetRcvdClientCert` and `NumReceivedClientCerts` still work, but only the
+   * client's own certificate is restored and not the rest of its chain.
+   *
+   * This property is read-only.
+   */
+  readonly tlsSessionResumed: boolean
+
   // ---- Methods ----
 
   /**
@@ -3308,6 +3407,86 @@ export interface Socket extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    */
   sshNewChannelAsync(hostname: string, port: number, ssl: boolean, maxWaitMs: number, channel: Socket): Promise<void>
 
+  /**
+   * Adds a server certificate to be presented when a TLS client's SNI (Server Name Indication)
+   * hostname matches `hostname`. This allows one listening socket to serve more than one hostname,
+   * each with its own certificate. The certificate must have access to its corresponding private
+   * key.
+   *
+   * `hostname` may be an exact name such as `www.example.com`, a leading wildcard such as
+   * `*.example.com`, or an empty string to add a default certificate. Call this method once for
+   * each certificate.
+   *
+   * The certificate for a connection is chosen after the client's ClientHello has been read, in
+   * this order, with the first match winning:
+   *
+   * - an exact, case-insensitive match on the hostname;
+   *
+   * - a leading-wildcard match, where `*.example.com` matches `a.example.com` but neither
+   *   `example.com` nor `a.b.example.com`;
+   *
+   * - a default certificate added by this method with an empty hostname;
+   *
+   * - the certificate passed to `InitSslServer`.
+   *
+   * A client that sends no SNI hostname goes directly to step 3. Two certificates may be added for
+   * the same hostname, in which case the first one added is used.
+   *
+   * **Call order does not matter:** Unlike `AddSslAcceptableClientCaDn`, this method may be called
+   * before or after `InitSslServer`, and also while the socket is already listening.
+   * `InitSslServer` is still required: it installs the default certificate and configures the
+   * socket for server-side TLS.
+   *
+   * **The certificate object may be released:** This method keeps its own reference to the
+   * certificate, so the application may discard `cert` as soon as the call returns.
+   *
+   * The hostname the client asked for can be read from the `SniHostname` property of the socket
+   * returned by `AcceptNext`. To refuse a connection whose requested hostname matches nothing, set
+   * `RequireSniMatch`.
+   *
+   * Returns `true` for success, `false` for failure. Failure includes a certificate with no
+   * accessible private key, which is reported here rather than during a later handshake.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Socket.lastErrorText}.
+   */
+  addSslServerCert(cert: Cert, hostname: string): void
+
+  /**
+   * Removes every certificate added by `AddSslServerCert`.
+   *
+   * The certificate installed by `InitSslServer` is not affected and remains the default for
+   * connections whose SNI hostname matches nothing.
+   */
+  clearSslServerCerts(): void
+
+  /**
+   * Sets the key this TLS server uses to encrypt and decrypt session tickets. `binKey` must contain
+   * exactly 32 bytes.
+   *
+   * This is only needed so that tickets issued by one server process remain valid in another
+   * process, or after a restart. A random key is generated automatically otherwise, which makes
+   * session resumption work for the life of one listener with no configuration at all. Every server
+   * instance that should accept one another's tickets must be given the same key.
+   *
+   * Calling this method a second time with a different key rotates the key: new tickets are issued
+   * under the new key, and tickets issued under the key it replaces are still accepted until they
+   * expire. Calling it with the key already in use does nothing, so re-reading an unchanged
+   * configuration is harmless.
+   *
+   * **Protect this key:** It encrypts the resumption secret of every session whose ticket it
+   * issued. Anyone holding it can decrypt those tickets. Store it as securely as a private key, and
+   * rotate it periodically.
+   *
+   * Set `TlsTicketLifetimeSeconds` to `0` to issue no tickets at all.
+   *
+   * Returns `true` for success, `false` for failure.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link Socket.lastErrorText}.
+   */
+  setTlsTicketKey(binKey: BinData): void
+
   // ---- Events (ReactNativeGen_DESIGN.md §6) ----
 
   /**

package/src/specs/Spider.nitro.ts

@@ -438,22 +438,16 @@ export interface Spider extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    *
    * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
    * {@link Spider.crawlNextAsync}.
-   *
-   * @throws Error if the call fails (the message names the reason); the full log is in
-   * {@link Spider.lastErrorText}.
    */
-  crawlNext(): void
+  crawlNext(): boolean
 
   /**
    * Asynchronous form of {@link Spider.crawlNext}: the same call on a native worker thread,
    * settling on the JavaScript thread. While it is pending, other calls on this object throw,
    * except {@link Spider.abort} (which cancels it) and the {@link Spider.onPercentDone} /
    * {@link Spider.onProgressInfo} callbacks, which report progress while it runs.
-   *
-   * The promise rejects with an Error if the call fails; the full log is in
-   * {@link Spider.lastErrorText}.
    */
-  crawlNextAsync(): Promise<void>
+  crawlNextAsync(): Promise<boolean>
 
   /**
    * Returns the contents of the robots.txt file from the domain being crawled. This spider object
@@ -554,22 +548,16 @@ export interface Spider extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    *
    * This call blocks the JavaScript thread until Chilkat returns; from UI code prefer
    * {@link Spider.recrawlLastAsync}.
-   *
-   * @throws Error if the call fails (the message names the reason); the full log is in
-   * {@link Spider.lastErrorText}.
    */
-  recrawlLast(): void
+  recrawlLast(): boolean
 
   /**
    * Asynchronous form of {@link Spider.recrawlLast}: the same call on a native worker thread,
    * settling on the JavaScript thread. While it is pending, other calls on this object throw,
    * except {@link Spider.abort} (which cancels it) and the {@link Spider.onPercentDone} /
    * {@link Spider.onProgressInfo} callbacks, which report progress while it runs.
-   *
-   * The promise rejects with an Error if the call fails; the full log is in
-   * {@link Spider.lastErrorText}.
    */
-  recrawlLastAsync(): Promise<void>
+  recrawlLastAsync(): Promise<boolean>
 
   /**
    * Moves a URL from the unspidered list to the spidered list. This allows an application to skip a

package/src/specs/Ssh.nitro.ts

@@ -851,26 +851,44 @@ export interface Ssh extends HybridObject<{ ios: 'c++', android: 'c++' }> {
   abortCurrent: boolean
 
   /**
-   * Controls whether ANSI SGR color and text-style sequences are removed from normal received text
-   * returned by {@link Ssh.getReceivedText} and {@link Ssh.getReceivedTextS}. The default is
-   * `true`.
+   * Controls whether terminal control sequences are removed from received text, so that the text
+   * returned is plain text. It applies to {@link Ssh.getReceivedText}, {@link Ssh.getReceivedSb}
+   * and {@link Ssh.getReceivedTextS}. The default is `true`.
    *
-   * It removes ESC-prefixed CSI sequences ending in `m`, including empty, semicolon-separated, and
-   * colon-separated parameter forms such as `ESC[m`, `ESC[1;31m`, `ESC[38;5;196m`, and
-   * `ESC[38:5:196m`.
+   * These are removed:
    *
-   * It does not remove non-SGR CSI sequences such as `ESC[2J`, OSC sequences, 8-bit C1 CSI
-   * sequences beginning with byte `0x9B`, or an incomplete trailing SGR sequence.
+   * - CSI sequences: `ESC[`, then optional parameter and intermediate bytes, then a final byte.
+   *   These include colors and text styles (`ESC[1;31m`, `ESC[38:5:196m`), cursor movement and
+   *   erasing (`ESC[H`, `ESC[K`, `ESC[2J`), mode changes such as bracketed paste (`ESC[?2004h`),
+   *   and terminal queries (`ESC[6n`).
+   *
+   * - OSC, DCS, SOS, PM and APC strings, ended by `ESC\` or BEL. For example, window titles
+   *   (`ESC]0;title`), and the OSC 3008 context sequences that newer versions of systemd send
+   *   around shell prompts.
+   *
+   * - Other escape sequences, such as `ESC 7`, `ESC 8`, `ESC =`, `ESC >` and `ESC ( B`.
+   *
+   * - The BEL, SO and SI control characters.
+   *
+   * Line breaks (CR and LF), tabs and all other text are kept. 8-bit C1 control bytes such as
+   * `0x9B` are not removed, because those byte values also occur within UTF-8 characters. A
+   * malformed sequence loses only its ESC.
+   *
+   * A sequence split across SSH packets is still removed: if the received text ends with an
+   * unfinished sequence, those bytes are held back and returned with the text received next. They
+   * are returned as received if the channel has received EOF or CLOSE, or the connection was lost.
+   * An unusually long sequence (over 256 bytes for CSI, or over 16384 bytes for a control string)
+   * is not held back; only its ESC is removed.
    *
    * For `GetReceivedTextS`, stripping applies to both the literal substring search and the returned
    * value; the corresponding original raw escape-sequence bytes are consumed.
    *
-   * It does not affect raw-byte getters, {@link Ssh.peekReceivedText}, {@link
-   * Ssh.getReceivedStderrText}, pattern matching in {@link Ssh.channelReceiveUntilMatch}, or the
-   * string returned by {@link Ssh.quickCommand}.
+   * It does not affect raw-byte getters, {@link Ssh.peekReceivedText}, pattern matching in {@link
+   * Ssh.channelReceiveUntilMatch}, or the string returned by {@link Ssh.quickCommand}.
    *
-   * An SGR sequence split across SSH packets can still be removed if all of its bytes remain
-   * buffered until the text is retrieved.
+   * Only escape sequences and the control characters listed above are removed. Text that the server
+   * sends as plain characters stays: for example, the `%` and spaces that zsh writes before a
+   * prompt (its `PROMPT_SP` option).
    */
   stripColorCodes: boolean
 

package/src/specs/StringBuilder.nitro.ts

@@ -917,4 +917,59 @@ export interface StringBuilder extends HybridObject<{ ios: 'c++', android: 'c++'
    * {@link StringBuilder.lastErrorText}.
    */
   appendLn(str: string): void
+
+  /**
+   * Converts the HTML contained in this object to Markdown, replacing the contents with the
+   * Markdown. Returns `true` on success. If the conversion fails, the contents are left unchanged
+   * and the reason is in the LastErrorText.
+   *
+   * This is the reverse of {@link StringBuilder.markdownToHtml}. The HTML is parsed with the same
+   * parser used by `Html.ToXml` and `Html.ToText`, and the resulting document tree produces
+   * CommonMark / GitHub-flavored Markdown:
+   *
+   * - `h1` through `h6` become `#` .. `######` headings.
+   *
+   * - `p`, `div`, `section` and other block-level elements become paragraphs separated by a blank
+   *   line. `br` becomes a hard line break and `hr` becomes `---`.
+   *
+   * - `b`/`strong` become `**bold**`, `i`/`em`/`cite` become `*italic*`, `del`/`s`/`strike` become
+   *   `~~struck~~`, and `code`/`kbd`/`samp` become a backtick code span.
+   *
+   * - `pre` becomes a fenced code block. The language is taken from a `language-xxx` or `lang-xxx`
+   *   class on the `pre` or its `code` child.
+   *
+   * - `a href` becomes `[text](url "title")`, and `img` becomes `![alt](src "title")`.
+   *
+   * - `ul`/`ol`/`li` become `-` and `1.` lists, with nested lists indented. A checkbox `input`
+   *   inside a list item becomes `[ ]` or `[x]`.
+   *
+   * - `blockquote` becomes lines prefixed with `>`.
+   *
+   * - `table` becomes a GitHub pipe table. The first row is the header when it contains `th` cells
+   *   or is inside a `thead`; `colspan` is honored, and `align` or `text-align` sets the column
+   *   alignment. A single-column table becomes plain paragraphs, because such tables are usually
+   *   for layout.
+   *
+   * - `dl`/`dt`/`dd` become a term line followed by `: definition` lines.
+   *
+   * `head`, `script`, `style`, `title`, `meta`, `link`, `noscript`, `iframe`, `object`, `embed`,
+   * `svg`, `canvas`, form controls and comments produce no output. Any other tag is transparent:
+   * only its content is emitted.
+   *
+   * Markdown-significant punctuation in ordinary text is backslash-escaped so that the text renders
+   * literally. Text inside `code` and `pre` is never escaped. HTML entities are decoded.
+   *
+   * The Markdown uses LF line endings, always ends with a single line ending, and never contains
+   * more than one consecutive blank line outside of a code block. Call {@link StringBuilder.toCRLF}
+   * afterwards for CRLF line endings.
+   *
+   * **Note:** The conversion is in-place. The HTML is not available after a successful call, so
+   * load it into a separate `StringBuilder` first if it is still needed.
+   *
+   * Empty contents, or HTML with no visible content, produce empty contents and `true` is returned.
+   *
+   * @throws Error if the call fails (the message names the reason); the full log is in
+   * {@link StringBuilder.lastErrorText}.
+   */
+  htmlToMarkdown(): void
 }

package/src/specs/ZipEntry.nitro.ts

@@ -735,11 +735,8 @@ export interface ZipEntry extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    *
    * Returns `_TRUE_` if a matching entry is found. Returns
    * `_FALSE_` if no further matching entry exists.
-   *
-   * @throws Error if the call fails (the message names the reason); the full log is in
-   * {@link ZipEntry.lastErrorText}.
    */
-  getNextMatch(pattern: string): void
+  getNextMatch(pattern: string): boolean
 
   /**
    * Updates this `ZipEntry` object so that it represents the
@@ -749,11 +746,8 @@ export interface ZipEntry extends HybridObject<{ ios: 'c++', android: 'c++' }> {
    *
    * Returns `_TRUE_` if the object was advanced to the next
    * entry. Returns `_FALSE_` if there are no more entries.
-   *
-   * @throws Error if the call fails (the message names the reason); the full log is in
-   * {@link ZipEntry.lastErrorText}.
    */
-  getNext(): void
+  getNext(): boolean
 
   // ---- Events (ReactNativeGen_DESIGN.md §6) ----