@player-ui/player 0.8.0--canary.307.9621 → 0.8.0-next.0

package/src/expressions/utils.ts

@@ -1,16 +1,17 @@
-import { isExpressionNode } from './types';
+import { isExpressionNode } from "./types";
 import type {
+  ErrorWithLocation,
   ExpressionHandler,
   ExpressionNode,
   ExpressionObjectType,
   ExpressionType,
   NodeLocation,
   NodePosition,
-} from './types';
+} from "./types";
 
 /** Generates a function by removing the first context argument */
 export function withoutContext<T extends unknown[], Return>(
-  fn: (...args: T) => Return
+  fn: (...args: T) => Return,
 ): ExpressionHandler<T, Return> {
   return (_context, ...args) => fn(...args);
 }
@@ -26,16 +27,16 @@ function isInRange(position: NodePosition, location: NodeLocation) {
 /** Get the node in the expression that's closest to the desired position */
 export function findClosestNodeAtPosition(
   node: ExpressionNode,
-  position: NodePosition
+  position: NodePosition,
 ): ExpressionNode | undefined {
   // This is just mapping recursively over nodes in the tree
 
   // eslint-disable-next-line default-case
   switch (node.type) {
-    case 'Modification':
-    case 'Assignment':
-    case 'LogicalExpression':
-    case 'BinaryExpression': {
+    case "Modification":
+    case "Assignment":
+    case "LogicalExpression":
+    case "BinaryExpression": {
       const check =
         findClosestNodeAtPosition(node.left, position) ??
         findClosestNodeAtPosition(node.right, position);
@@ -46,7 +47,7 @@ export function findClosestNodeAtPosition(
       break;
     }
 
-    case 'UnaryExpression': {
+    case "UnaryExpression": {
       const checkArg = findClosestNodeAtPosition(node.argument, position);
       if (checkArg) {
         return checkArg;
@@ -55,7 +56,7 @@ export function findClosestNodeAtPosition(
       break;
     }
 
-    case 'MemberExpression': {
+    case "MemberExpression": {
       const checkObject =
         findClosestNodeAtPosition(node.object, position) ??
         findClosestNodeAtPosition(node.property, position);
@@ -66,7 +67,7 @@ export function findClosestNodeAtPosition(
       break;
     }
 
-    case 'ConditionalExpression': {
+    case "ConditionalExpression": {
       const checkObject =
         findClosestNodeAtPosition(node.test, position) ??
         findClosestNodeAtPosition(node.consequent, position) ??
@@ -78,13 +79,13 @@ export function findClosestNodeAtPosition(
       break;
     }
 
-    case 'ArrayExpression':
-    case 'Compound': {
+    case "ArrayExpression":
+    case "Compound": {
       const elements =
-        node.type === 'ArrayExpression' ? node.elements : node.body;
+        node.type === "ArrayExpression" ? node.elements : node.body;
 
       const anyElements = elements.find((e) =>
-        findClosestNodeAtPosition(e, position)
+        findClosestNodeAtPosition(e, position),
       );
 
       if (anyElements) {
@@ -94,7 +95,7 @@ export function findClosestNodeAtPosition(
       break;
     }
 
-    case 'Object': {
+    case "Object": {
       const checkObject = node.attributes.reduce<ExpressionNode | undefined>(
         (found, next) => {
           return (
@@ -103,7 +104,7 @@ export function findClosestNodeAtPosition(
             findClosestNodeAtPosition(next.value, position)
           );
         },
-        undefined
+        undefined,
       );
 
       if (checkObject) {
@@ -113,7 +114,7 @@ export function findClosestNodeAtPosition(
       break;
     }
 
-    case 'CallExpression': {
+    case "CallExpression": {
       const anyArgs =
         node.args.find((arg) => {
           return findClosestNodeAtPosition(arg, position);
@@ -135,16 +136,26 @@ export function findClosestNodeAtPosition(
 
 /** Checks if the expression is a simple type */
 export function isObjectExpression(
-  expr: ExpressionType
+  expr: ExpressionType,
 ): expr is ExpressionObjectType {
   if (isExpressionNode(expr)) {
     return false;
   }
 
   return (
-    typeof expr === 'object' &&
+    typeof expr === "object" &&
     expr !== null &&
     !Array.isArray(expr) &&
-    'value' in expr
+    "value" in expr
+  );
+}
+
+/**
+ * Type guard for ErrorWithLocation
+ */
+export function isErrorWithLocation(error: Error): error is ErrorWithLocation {
+  return (
+    (error as ErrorWithLocation).index !== undefined &&
+    (error as ErrorWithLocation).description !== undefined
   );
 }

package/src/index.ts

@@ -1,15 +1,15 @@
 // Add the types export first so it's naming takes precedence
-export * from '@player-ui/types';
-export * from './binding';
-export * from './data';
-export * from './expressions';
-export * from './logger';
-export * from './schema';
-export * from './string-resolver';
-export * from './validator';
-export * from './view';
+export * from "@player-ui/types";
+export * from "./binding/index";
+export * from "./data/index";
+export * from "./expressions/index";
+export * from "./logger/index";
+export * from "./schema/index";
+export * from "./string-resolver/index";
+export * from "./validator/index";
+export * from "./view/index";
 
-export * from './player';
-export * from './controllers';
-export * from './types';
-export * from './plugins/flow-exp-plugin';
+export * from "./player";
+export * from "./controllers/index";
+export * from "./types";
+export * from "./plugins/flow-exp-plugin";

package/src/logger/__tests__/consoleLogger.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, vitest, beforeEach } from "vitest";
+import { ConsoleLogger } from "..";
+import type { ConsoleHandler } from "../consoleLogger";
+
+describe("console logger", () => {
+  let consoleFns: ConsoleHandler;
+
+  beforeEach(() => {
+    consoleFns = {
+      log: vitest.fn(),
+      warn: vitest.fn(),
+      error: vitest.fn(),
+    };
+  });
+
+  it("calls console fns", () => {
+    const logger = new ConsoleLogger("warn", consoleFns);
+    logger.warn("test warning");
+
+    expect(consoleFns.warn).toBeCalledTimes(1);
+    expect(consoleFns.warn).toBeCalledWith("player - warn -", "test warning");
+  });
+
+  it("handles severity", () => {
+    const logger = new ConsoleLogger("warn", consoleFns);
+    logger.warn("test warning");
+    expect(consoleFns.warn).toBeCalledTimes(1);
+
+    logger.info("test info");
+    expect(consoleFns.log).toBeCalledTimes(0);
+
+    logger.setSeverity("info");
+    logger.info("test info");
+    expect(consoleFns.log).toBeCalledTimes(1);
+    expect(consoleFns.log).toBeCalledWith("player - info -", "test info");
+
+    logger.setSeverity("trace");
+    logger.debug("test debug");
+    expect(consoleFns.log).toBeCalledTimes(2);
+    expect(consoleFns.log).toBeCalledWith("player - debug -", "test debug");
+
+    logger.error("errrr");
+    expect(consoleFns.error).toBeCalledTimes(1);
+    expect(consoleFns.error).toBeCalledWith("player - error -", "errrr");
+  });
+});

package/src/logger/__tests__/noopLogger.test.ts

@@ -0,0 +1,13 @@
+import { test, expect } from "vitest";
+import { NoopLogger, severities } from "..";
+import type { LogFn } from "../types";
+
+test("does nothing - like it should", () => {
+  const logger = new NoopLogger();
+
+  severities.forEach((s) => {
+    (logger[s] as LogFn)("foo");
+  });
+
+  expect(true).toBe(true);
+});

package/src/logger/__tests__/proxyLogger.test.ts

@@ -0,0 +1,31 @@
+import { test, expect, vitest } from "vitest";
+import type { Logger } from "../types";
+import ProxyLogger from "../proxyLogger";
+
+test("proxyLogger works with no logger", () => {
+  const proxyLogger = new ProxyLogger(() => undefined);
+  expect(() => proxyLogger.info("foo")).not.toThrow();
+});
+
+test("calls real logger when set", () => {
+  const testLogger: Logger = {
+    trace: vitest.fn(),
+    debug: vitest.fn(),
+    info: vitest.fn(),
+    warn: vitest.fn(),
+    error: vitest.fn(),
+  };
+
+  let useTestLogger = false;
+
+  const proxyLogger = new ProxyLogger(() =>
+    useTestLogger ? testLogger : undefined,
+  );
+
+  proxyLogger.error("err");
+  expect(testLogger.error).toBeCalledTimes(0);
+
+  useTestLogger = true;
+  proxyLogger.error("err");
+  expect(testLogger.error).toBeCalledTimes(1);
+});

package/src/logger/__tests__/tapableLogger.test.ts

@@ -0,0 +1,41 @@
+import { test, expect, vitest } from "vitest";
+import { TapableLogger } from "..";
+import type { Logger } from "../types";
+import { severities } from "../types";
+
+test("works via logger api", () => {
+  const logger = new TapableLogger();
+
+  const testLogger: Logger = {
+    trace: vitest.fn(),
+    debug: vitest.fn(),
+    info: vitest.fn(),
+    warn: vitest.fn(),
+    error: vitest.fn(),
+  };
+
+  logger.addHandler(testLogger);
+
+  severities.forEach((s) => {
+    logger[s](s);
+  });
+
+  severities.forEach((s) => {
+    expect(testLogger[s]).toBeCalledTimes(1);
+    expect(testLogger[s]).toBeCalledWith(s);
+  });
+
+  severities.forEach((s) => {
+    (testLogger[s] as jest.Mock<any, any>).mockClear();
+  });
+
+  logger.removeHandler(testLogger);
+
+  severities.forEach((s) => {
+    logger[s](s);
+  });
+
+  severities.forEach((s) => {
+    expect(testLogger[s]).toBeCalledTimes(0);
+  });
+});

package/src/logger/consoleLogger.ts

@@ -1,14 +1,14 @@
-import type { Logger, Severity } from './types';
-import { severities } from './types';
+import type { Logger, Severity } from "./types";
+import { severities } from "./types";
 
-export type ConsoleHandler = Pick<typeof console, 'log' | 'warn' | 'error'>;
+export type ConsoleHandler = Pick<typeof console, "log" | "warn" | "error">;
 
 /** A Logger implementation that uses console */
 export default class ConsoleLogger implements Logger {
   private severity: Severity;
   private _console: ConsoleHandler;
 
-  constructor(severity: Severity = 'warn', _console: ConsoleHandler = console) {
+  constructor(severity: Severity = "warn", _console: ConsoleHandler = console) {
     this.severity = severity;
     this._console = _console;
   }
@@ -41,9 +41,9 @@ export default class ConsoleLogger implements Logger {
     };
   }
 
-  public readonly trace = this.createHandler('trace');
-  public readonly debug = this.createHandler('debug');
-  public readonly info = this.createHandler('info');
-  public readonly warn = this.createHandler('warn');
-  public readonly error = this.createHandler('error');
+  public readonly trace = this.createHandler("trace");
+  public readonly debug = this.createHandler("debug");
+  public readonly info = this.createHandler("info");
+  public readonly warn = this.createHandler("warn");
+  public readonly error = this.createHandler("error");
 }

package/src/logger/index.ts

@@ -1,5 +1,5 @@
-export * from './types';
-export { default as ConsoleLogger } from './consoleLogger';
-export { default as NoopLogger } from './noopLogger';
-export { default as TapableLogger } from './tapableLogger';
-export { default as ProxyLogger } from './proxyLogger';
+export * from "./types";
+export { default as ConsoleLogger } from "./consoleLogger";
+export { default as NoopLogger } from "./noopLogger";
+export { default as TapableLogger } from "./tapableLogger";
+export { default as ProxyLogger } from "./proxyLogger";

package/src/logger/noopLogger.ts

@@ -1,4 +1,4 @@
-import type { Logger } from './types';
+import type { Logger } from "./types";
 
 /** An empty function so the logger ignore everything */
 const noop = () => {};

package/src/logger/proxyLogger.ts

@@ -1,4 +1,4 @@
-import type { Logger, Severity, LoggerProvider } from './types';
+import type { Logger, Severity, LoggerProvider } from "./types";
 
 /**
  * The ProxyLogger allows a user to log to another Logger instance that may not exist yet
@@ -17,9 +17,9 @@ export default class ProxyLogger implements Logger {
     };
   }
 
-  public readonly trace = this.createHandler('trace');
-  public readonly debug = this.createHandler('debug');
-  public readonly info = this.createHandler('info');
-  public readonly warn = this.createHandler('warn');
-  public readonly error = this.createHandler('error');
+  public readonly trace = this.createHandler("trace");
+  public readonly debug = this.createHandler("debug");
+  public readonly info = this.createHandler("info");
+  public readonly warn = this.createHandler("warn");
+  public readonly error = this.createHandler("error");
 }

package/src/logger/tapableLogger.ts

@@ -1,5 +1,5 @@
-import { SyncHook } from 'tapable-ts';
-import type { Logger, Severity } from './types';
+import { SyncHook } from "tapable-ts";
+import type { Logger, Severity } from "./types";
 
 /** A logger that has a tapable subscriptions to callbacks */
 export default class TapableLogger implements Logger {
@@ -30,9 +30,9 @@ export default class TapableLogger implements Logger {
     this.logHandlers.delete(logHandler);
   }
 
-  public readonly trace = this.createHandler('trace');
-  public readonly debug = this.createHandler('debug');
-  public readonly info = this.createHandler('info');
-  public readonly warn = this.createHandler('warn');
-  public readonly error = this.createHandler('error');
+  public readonly trace = this.createHandler("trace");
+  public readonly debug = this.createHandler("debug");
+  public readonly info = this.createHandler("info");
+  public readonly warn = this.createHandler("warn");
+  public readonly error = this.createHandler("error");
 }

package/src/logger/types.ts

@@ -1,6 +1,6 @@
 export type LogFn = (...args: Array<any>) => void;
 
-export const severities = ['trace', 'debug', 'info', 'warn', 'error'] as const;
-export type Severity = typeof severities[number];
+export const severities = ["trace", "debug", "info", "warn", "error"] as const;
+export type Severity = (typeof severities)[number];
 export type Logger = Record<Severity, LogFn>;
 export type LoggerProvider = () => Logger | undefined;