@api-client/core 0.3.1 → 0.3.4

package/src/models/HistoryRequest.ts

@@ -0,0 +1,28 @@
+import { IRequest, Request } from './Request.js';
+
+export const Kind = 'ARC#HistoryRequest';
+
+/**
+ * A class that specializes in processing ARC history request object.
+ */
+export class HistoryRequest extends Request {
+  kind = Kind;
+
+  /**
+   * Generates an id for a history object
+   */
+  generateId(): string {
+    const { method='', url='' } = this.expects;
+    const d = new Date();
+    d.setHours(0, 0, 0, 0);
+    const time = d.getTime();
+    const encUrl = encodeURIComponent(url);
+    return `${time}/${encUrl}/${method}`;
+  }
+
+  toJSON(): IRequest {
+    const result = super.toJSON();
+    result.kind = Kind;
+    return result;
+  }
+}

package/src/models/HostRule.ts

@@ -0,0 +1,163 @@
+export const Kind = 'ARC#HostRule';
+
+/**
+ * ARC host rule definition.
+ */
+export interface IHostRule {
+  kind?: typeof Kind;
+  /**
+   * The from rule (may contain asterisks)
+   */
+  from: string;
+  /**
+   * replacement value
+   */
+  to: string;
+  /**
+   * if false the rule is ignored
+   */
+  enabled?: boolean;
+  /**
+   * optional rule description
+   */
+  comment?: string;
+}
+
+export class HostRule {
+  kind = Kind;
+  /**
+   * The from rule (may contain asterisks)
+   */
+  from = '';
+  /**
+   * replacement value
+   */
+  to = '';
+  /**
+   * if false the rule is ignored
+   */
+  enabled?: boolean;
+  /**
+   * optional rule description
+   */
+  comment?: string;
+
+  static fromValues(from: string, to: string ): HostRule {
+    const result = new HostRule({
+      kind: Kind,
+      from,
+      to,
+      enabled: true,
+    });
+    return result;
+  }
+
+  /**
+   * @param input The thing definition used to restore the state.
+   */
+  constructor(input?: string | IHostRule) {
+    let init: IHostRule;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        kind: Kind,
+        from: '',
+        to: '',
+      };
+    }
+    this.new(init);
+  }
+
+  /**
+   * Creates a new thing clearing anything that is so far defined.
+   * 
+   * Note, this throws an error when the server is not an ARC thing.
+   */
+  new(init: IHostRule): void {
+    if (!HostRule.isHostRule(init)) {
+      throw new Error(`Not an ARC HostRule.`);
+    }
+    const { from='', to='', enabled, comment } = init;
+    this.kind = Kind;
+    this.from = from;
+    this.to = to;
+    this.enabled = enabled;
+    this.comment = comment;
+  }
+
+  /**
+   * Checks whether the input is a definition of a host rule.
+   */
+  static isHostRule(input: unknown): boolean {
+    const typed = input as IHostRule;
+    if (input && typed.kind && typed.kind === Kind) {
+      return true;
+    }
+    return false;
+  }
+
+  toJSON(): IHostRule {
+    const result: IHostRule = {
+      kind: Kind,
+      from : this.from,
+      to : this.to,
+    };
+    if (typeof this.enabled === 'boolean') {
+      result.enabled = this.enabled;
+    }
+    if (this.comment) {
+      result.comment = this.comment;
+    }
+    return result;
+  }
+
+  /**
+   * Applies `hosts` rules to the URL.
+   *
+   * @param value An URL to apply the rules to
+   * @param rules List of host rules. It is a list of objects containing `from` and `to` properties.
+   * @return Evaluated URL with hosts rules.
+   */
+  static applyHosts(value: string, rules: HostRule[]): string {
+    if (!rules || !rules.length) {
+      return value;
+    }
+    for (let i = 0; i < rules.length; i++) {
+      const rule = rules[i];
+      const result = HostRule.evaluateRule(value, rule);
+      if (result) {
+        value = result;
+      }
+    }
+    return value;
+  }
+
+  /**
+   * Evaluates hosts rule and applies it to the `url`.
+   * @param {string} url The URL to evaluate
+   * @param {HostRule} rule ARC rule definition
+   * @return {string} Processed url.
+   */
+  static evaluateRule(url: string, rule: HostRule): string | undefined {
+    if (!rule || !rule.from || !rule.to) {
+      return;
+    }
+    const re = HostRule.createRuleRe(rule.from);
+    if (!re.test(url)) {
+      return;
+    }
+    return url.replace(re, rule.to);
+  }
+
+  /**
+   * @param input Rule body
+   * @return Regular expression for the rule.
+   */
+  static createRuleRe(input: string): RegExp {
+    input = input.replace(/\*/g, '(.*)');
+    return new RegExp(input, 'gi');
+  }
+}

package/src/models/HttpCookie.ts

@@ -0,0 +1,285 @@
+import { ARCCookie as LegacyARCCookie } from './legacy/models/Cookies.js';
+import { Cookie as ParserCookie } from '../lib/cookies/Cookie.js';
+
+export type CookieSameSiteType = 'unspecified' | 'no_restriction' | 'lax' | 'strict';
+export type CookieChangeReason = 'explicit' | 'overwrite' | 'expired' | 'evicted' | 'expired-overwrite';
+
+export interface IHttpCookieChangeRecord {
+  /**
+   * The cookie that was changed.
+   */
+  cookie: IHttpCookie;
+  /**
+   * The cause of the change with one of the following values:
+   * - `explicit` - The cookie was changed directly by a consumer's action.
+   * - `overwrite` - The cookie was automatically removed due to an insert operation that overwrote it.
+   * - `expired` - The cookie was automatically removed as it expired.
+   * - `evicted` - The cookie was automatically evicted during garbage collection.
+   * - `expired-overwrite` - The cookie was overwritten with an already-expired expiration date.
+   */
+  cause: CookieChangeReason;
+  /**
+   * `true` if the cookie was removed, `false` otherwise.
+   */
+  removed: boolean;
+}
+
+export interface IHttpCookie {
+  // https://www.electronjs.org/docs/latest/api/structures/cookie
+  /**
+   * The name of the cookie.
+   */
+  name: string;
+  /**
+   * The value of the cookie.
+   */
+  value: string;
+  /**
+   * The domain of the cookie; this will be normalized with a preceding dot so that
+   * it's also valid for subdomains.
+   */
+  domain?: string;
+  /**
+   * Whether the cookie is a host-only cookie; this will only be `true` if no domain
+   * was passed.
+   */
+  hostOnly?: boolean;
+  /**
+   * The path of the cookie.
+   */
+  path?: string;
+  /**
+   * Whether the cookie is marked as secure.
+   */
+  secure?: boolean;
+  /**
+   * Whether the cookie is marked as HTTP only.
+   */
+  httpOnly?: boolean;
+  /**
+   * Whether the cookie is a session cookie or a persistent cookie with an expiration
+   * date.
+   */
+  session?: boolean;
+  /**
+   * The expiration date of the cookie as the number of seconds since the UNIX epoch.
+   * Not provided for session cookies.
+   */
+  expirationDate?: number;
+  /**
+   * The Same Site policy applied to this cookie. Can be `unspecified`, `no_restriction`, `lax` or `strict`.
+   * @default unspecified
+   */
+  sameSite: CookieSameSiteType;
+}
+
+export class HttpCookie {
+  /**
+   * The name of the cookie.
+   */
+  name = '';
+  /**
+   * The value of the cookie.
+   */
+  value = '';
+  /**
+   * The domain of the cookie; this will be normalized with a preceding dot so that
+   * it's also valid for subdomains.
+   */
+  domain?: string;
+  /**
+   * Whether the cookie is a host-only cookie; this will only be `true` if no domain
+   * was passed.
+   */
+  hostOnly?: boolean;
+  /**
+   * The path of the cookie.
+   */
+  path?: string;
+  /**
+   * Whether the cookie is marked as secure.
+   */
+  secure?: boolean;
+  /**
+   * Whether the cookie is marked as HTTP only.
+   */
+  httpOnly?: boolean;
+  /**
+   * Whether the cookie is a session cookie or a persistent cookie with an expiration
+   * date.
+   */
+  session?: boolean;
+  /**
+   * The expiration date of the cookie as the number of seconds since the UNIX epoch.
+   * Not provided for session cookies.
+   */
+  expirationDate?: number;
+  /**
+   * The Same Site policy applied to this cookie. Can be `unspecified`, `no_restriction`, `lax` or `strict`.
+   * @default unspecified
+   */
+  sameSite: CookieSameSiteType = 'unspecified';
+
+  static fromLegacy(old: LegacyARCCookie): HttpCookie {
+    const init: IHttpCookie = {
+      name: old.name,
+      value: old.value || '',
+      sameSite: 'unspecified',
+    };
+    if (old.domain) {
+      init.domain = old.domain;
+    }
+    if (typeof old.expires === 'number') {
+      init.expirationDate = old.expires;
+    }
+    if (typeof old.hostOnly === 'boolean') {
+      init.hostOnly = old.hostOnly;
+    }
+    if (typeof old.httpOnly === 'boolean') {
+      init.httpOnly = old.httpOnly;
+    }
+    if (typeof old.path === 'string') {
+      init.path = old.path;
+    }
+    if (typeof old.secure === 'boolean') {
+      init.secure = old.secure;
+    }
+    if (typeof old.session === 'boolean') {
+      init.session = old.session;
+    }
+    return new HttpCookie(init);
+  }
+
+  static fromValue(name: string, value: string = ''): HttpCookie {
+    const init: IHttpCookie = {
+      name,
+      value,
+      sameSite: 'unspecified',
+    };
+    return new HttpCookie(init);
+  }
+
+  static fromCookieParser(cookie: ParserCookie): HttpCookie {
+    const { name, value, sameSite='unspecified' } = cookie;
+    const init: IHttpCookie = {
+      name,
+      value,
+      sameSite,
+    };
+    if (typeof cookie.domain === 'string') {
+      init.domain = cookie.domain;
+    }
+    if (typeof cookie.path === 'string') {
+      init.path = cookie.path;
+    }
+    if (typeof cookie.expires === 'number') {
+      init.expirationDate = cookie.expires;
+    }
+    if (typeof cookie.hostOnly === 'boolean') {
+      init.hostOnly = cookie.hostOnly;
+    }
+    if (typeof cookie.httpOnly === 'boolean') {
+      init.httpOnly = cookie.httpOnly;
+    }
+    if (typeof cookie.secure === 'boolean') {
+      init.secure = cookie.secure;
+    }
+    if (typeof cookie.persistent === 'boolean') {
+      init.session = !cookie.persistent;
+    }
+    return new HttpCookie(init);
+  }
+
+  constructor(input?: string|IHttpCookie) {
+    let init: IHttpCookie;
+    if (typeof input === 'string') {
+      init = JSON.parse(input);
+    } else if (typeof input === 'object') {
+      init = input;
+    } else {
+      init = {
+        name: '',
+        value: '',
+        sameSite: 'unspecified',
+      };
+    }
+    this.new(init);
+  }
+
+  new(init: IHttpCookie): void {
+    const {
+      name = '',
+      value = '',
+      sameSite = 'unspecified',
+      domain, expirationDate, hostOnly, httpOnly, path, secure, session
+    } = init;
+    this.name = name;
+    this.value = value;
+    this.sameSite = sameSite;
+    if (domain) {
+      this.domain = domain;
+    } else {
+      this.domain = undefined;
+    }
+    if (typeof expirationDate === 'number') {
+      this.expirationDate = expirationDate;
+    } else {
+      this.expirationDate = undefined;
+    }
+    if (typeof hostOnly === 'boolean') {
+      this.hostOnly = hostOnly;
+    } else {
+      this.hostOnly = undefined;
+    }
+    if (typeof httpOnly === 'boolean') {
+      this.httpOnly = httpOnly;
+    } else {
+      this.httpOnly = undefined;
+    }
+    if (typeof secure === 'boolean') {
+      this.secure = secure;
+    } else {
+      this.secure = undefined;
+    }
+    if (typeof session === 'boolean') {
+      this.session = session;
+    } else {
+      this.session = undefined;
+    }
+    if (typeof path === 'string') {
+      this.path = path;
+    } else {
+      this.path = undefined;
+    }
+  }
+
+  toJSON(): IHttpCookie {
+    const result: IHttpCookie = {
+      name: this.name,
+      value: this.value,
+      sameSite: this.sameSite,
+    };
+    if (this.domain) {
+      result.domain = this.domain;
+    }
+    if (typeof this.expirationDate === 'number') {
+      result.expirationDate = this.expirationDate;
+    }
+    if (typeof this.hostOnly === 'boolean') {
+      result.hostOnly = this.hostOnly;
+    }
+    if (typeof this.httpOnly === 'boolean') {
+      result.httpOnly = this.httpOnly;
+    }
+    if (typeof this.secure === 'boolean') {
+      result.secure = this.secure;
+    }
+    if (typeof this.session === 'boolean') {
+      result.session = this.session;
+    }
+    if (this.path) {
+      result.path = this.path;
+    }
+    return result;
+  }
+}