@percy/core 1.0.0 → 1.0.3

package/test/helpers/request.js

@@ -0,0 +1,15 @@
+export async function request(url, method = 'GET', handle) {
+  if (typeof method === 'boolean' || typeof method === 'function') [handle, method] = [method, 'GET'];
+  let cb = typeof handle === 'boolean' ? (handle ? (...a) => a : (_, r) => r) : handle;
+  let options = typeof method === 'string' ? { method } : method;
+  let { request } = await import('@percy/client/utils');
+
+  try {
+    return await request(url, options, cb);
+  } catch (error) {
+    if (typeof handle !== 'boolean') throw error;
+    return handle ? [error.response.body, error.response] : error.response;
+  }
+}
+
+export default request;

package/test/helpers/server.js

@@ -0,0 +1,33 @@
+// aliased to src for coverage during tests without needing to compile this file
+import Server from '../../dist/server.js';
+
+export function createTestServer({ default: defaultReply, ...replies }, port = 8000) {
+  let server = new Server();
+
+  // alternate route handling
+  let handleReply = reply => async (req, res) => {
+    let [status, headers, body] = typeof reply === 'function' ? await reply(req) : reply;
+    if (!Buffer.isBuffer(body) && typeof body !== 'string') body = JSON.stringify(body);
+    return res.send(status, headers, body);
+  };
+
+  // map replies to alternate route handlers
+  server.reply = (p, reply) => (replies[p] = handleReply(reply), null);
+  for (let [p, reply] of Object.entries(replies)) server.reply(p, reply);
+  if (defaultReply) defaultReply = handleReply(defaultReply);
+
+  // track requests and route replies
+  server.requests = [];
+  server.route(async (req, res, next) => {
+    let pathname = req.url.pathname;
+    if (req.url.search) pathname += req.url.search;
+    server.requests.push(req.body ? [pathname, req.body] : [pathname]);
+    let reply = replies[req.url.pathname] || defaultReply;
+    return reply ? await reply(req, res) : next();
+  });
+
+  // automatically listen
+  return server.listen(port);
+};
+
+export default createTestServer;

package/types/index.d.ts

@@ -0,0 +1,101 @@
+// utility types
+type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
+type XOR<T, U> = (T | U) extends object ? (Without<T, U> & U) | (Without<U, T> & T) : T | U;
+
+type LogLevel = 'error' | 'warn' | 'info' | 'debug' | 'silent';
+
+interface Pojo {
+  [x: string]: any;
+}
+
+interface AuthCredentials {
+  username: string;
+  password: string;
+}
+
+interface DiscoveryOptions {
+  requestHeaders?: Pojo;
+  authorization?: AuthCredentials;
+  allowedHostnames?: string[];
+  disableCache?: boolean;
+}
+
+interface DiscoveryLaunchOptions {
+  executable?: string;
+  args?: string[];
+  timeout?: number;
+  headless?: boolean;
+}
+
+interface AllDiscoveryOptions extends DiscoveryOptions {
+  networkIdleTimeout?: number;
+  concurrency?: number;
+  launchOptions?: DiscoveryLaunchOptions;
+}
+
+interface CommonSnapshotOptions {
+  widths?: number[];
+  minHeight?: number;
+  percyCSS?: string;
+  enableJavaScript?: boolean;
+}
+
+export interface SnapshotOptions extends CommonSnapshotOptions {
+  discovery?: DiscoveryOptions;
+}
+
+type ClientEnvInfo = {
+  clientInfo?: string,
+  environmentInfo?: string
+}
+
+export type PercyConfigOptions<C = Pojo> = C & {
+  snapshot?: CommonSnapshotOptions,
+  discovery?: AllDiscoveryOptions
+}
+
+export type PercyOptions<C = Pojo> = {
+  token?: string,
+  server?: boolean,
+  port?: number,
+  concurrency?: number,
+  loglevel?: LogLevel,
+  config?: undefined | string | false
+} & ClientEnvInfo & PercyConfigOptions<C>;
+
+type SnapshotExec = () => void | Promise<void>;
+
+type AdditionalSnapshot = (XOR<XOR<
+  { name: string },
+  { prefix: string, suffix?: string }>,
+  { suffix: string, prefix?: string }>
+) & { execute: SnapshotExec };
+
+declare class Percy {
+  static start(options?: PercyOptions): Promise<Percy>;
+  constructor(options?: PercyOptions);
+  loglevel(): LogLevel;
+  loglevel(level: LogLevel): void;
+  config: PercyConfigOptions;
+  setConfig(config: ClientEnvInfo & PercyConfigOptions): PercyConfigOptions;
+  start(): Promise<void>;
+  stop(force?: boolean): Promise<void>;
+  idle(): Promise<void>;
+  close(): void;
+
+  snapshot(options: {
+    url: string,
+    name?: string,
+    clientInfo?: string,
+    environmentInfo?: string
+  } & XOR<{
+    domSnapshot: string
+  }, {
+    waitForTimeout?: number,
+    waitForSelector?: string,
+    execute?: SnapshotExec,
+    additionalSnapshots?: AdditionalSnapshot[]
+  }> & SnapshotOptions): Promise<void>;
+}
+
+export default Percy;