skill-universe 1.1.0

package/build/dev/javascript/gleam_version

@@ -0,0 +1 @@
+1.14.0

package/build/dev/javascript/gleeunit/gleam.mjs

@@ -0,0 +1 @@
+export * from "../prelude.mjs";

package/build/dev/javascript/gleeunit/gleeunit/internal/gleam_panic.mjs

@@ -0,0 +1,180 @@
+import * as $dynamic from "../../../gleam_stdlib/gleam/dynamic.mjs";
+import { CustomType as $CustomType } from "../../gleam.mjs";
+import { from_dynamic } from "./gleeunit_gleam_panic_ffi.mjs";
+
+export { from_dynamic };
+
+export class GleamPanic extends $CustomType {
+  constructor(message, file, module, function$, line, kind) {
+    super();
+    this.message = message;
+    this.file = file;
+    this.module = module;
+    this.function = function$;
+    this.line = line;
+    this.kind = kind;
+  }
+}
+export const GleamPanic$GleamPanic = (message, file, module, function$, line, kind) =>
+  new GleamPanic(message, file, module, function$, line, kind);
+export const GleamPanic$isGleamPanic = (value) => value instanceof GleamPanic;
+export const GleamPanic$GleamPanic$message = (value) => value.message;
+export const GleamPanic$GleamPanic$0 = (value) => value.message;
+export const GleamPanic$GleamPanic$file = (value) => value.file;
+export const GleamPanic$GleamPanic$1 = (value) => value.file;
+export const GleamPanic$GleamPanic$module = (value) => value.module;
+export const GleamPanic$GleamPanic$2 = (value) => value.module;
+export const GleamPanic$GleamPanic$function = (value) => value.function;
+export const GleamPanic$GleamPanic$3 = (value) => value.function;
+export const GleamPanic$GleamPanic$line = (value) => value.line;
+export const GleamPanic$GleamPanic$4 = (value) => value.line;
+export const GleamPanic$GleamPanic$kind = (value) => value.kind;
+export const GleamPanic$GleamPanic$5 = (value) => value.kind;
+
+export class Todo extends $CustomType {}
+export const PanicKind$Todo = () => new Todo();
+export const PanicKind$isTodo = (value) => value instanceof Todo;
+
+export class Panic extends $CustomType {}
+export const PanicKind$Panic = () => new Panic();
+export const PanicKind$isPanic = (value) => value instanceof Panic;
+
+export class LetAssert extends $CustomType {
+  constructor(start, end, pattern_start, pattern_end, value) {
+    super();
+    this.start = start;
+    this.end = end;
+    this.pattern_start = pattern_start;
+    this.pattern_end = pattern_end;
+    this.value = value;
+  }
+}
+export const PanicKind$LetAssert = (start, end, pattern_start, pattern_end, value) =>
+  new LetAssert(start, end, pattern_start, pattern_end, value);
+export const PanicKind$isLetAssert = (value) => value instanceof LetAssert;
+export const PanicKind$LetAssert$start = (value) => value.start;
+export const PanicKind$LetAssert$0 = (value) => value.start;
+export const PanicKind$LetAssert$end = (value) => value.end;
+export const PanicKind$LetAssert$1 = (value) => value.end;
+export const PanicKind$LetAssert$pattern_start = (value) => value.pattern_start;
+export const PanicKind$LetAssert$2 = (value) => value.pattern_start;
+export const PanicKind$LetAssert$pattern_end = (value) => value.pattern_end;
+export const PanicKind$LetAssert$3 = (value) => value.pattern_end;
+export const PanicKind$LetAssert$value = (value) => value.value;
+export const PanicKind$LetAssert$4 = (value) => value.value;
+
+export class Assert extends $CustomType {
+  constructor(start, end, expression_start, kind) {
+    super();
+    this.start = start;
+    this.end = end;
+    this.expression_start = expression_start;
+    this.kind = kind;
+  }
+}
+export const PanicKind$Assert = (start, end, expression_start, kind) =>
+  new Assert(start, end, expression_start, kind);
+export const PanicKind$isAssert = (value) => value instanceof Assert;
+export const PanicKind$Assert$start = (value) => value.start;
+export const PanicKind$Assert$0 = (value) => value.start;
+export const PanicKind$Assert$end = (value) => value.end;
+export const PanicKind$Assert$1 = (value) => value.end;
+export const PanicKind$Assert$expression_start = (value) =>
+  value.expression_start;
+export const PanicKind$Assert$2 = (value) => value.expression_start;
+export const PanicKind$Assert$kind = (value) => value.kind;
+export const PanicKind$Assert$3 = (value) => value.kind;
+
+export class BinaryOperator extends $CustomType {
+  constructor(operator, left, right) {
+    super();
+    this.operator = operator;
+    this.left = left;
+    this.right = right;
+  }
+}
+export const AssertKind$BinaryOperator = (operator, left, right) =>
+  new BinaryOperator(operator, left, right);
+export const AssertKind$isBinaryOperator = (value) =>
+  value instanceof BinaryOperator;
+export const AssertKind$BinaryOperator$operator = (value) => value.operator;
+export const AssertKind$BinaryOperator$0 = (value) => value.operator;
+export const AssertKind$BinaryOperator$left = (value) => value.left;
+export const AssertKind$BinaryOperator$1 = (value) => value.left;
+export const AssertKind$BinaryOperator$right = (value) => value.right;
+export const AssertKind$BinaryOperator$2 = (value) => value.right;
+
+export class FunctionCall extends $CustomType {
+  constructor(arguments$) {
+    super();
+    this.arguments = arguments$;
+  }
+}
+export const AssertKind$FunctionCall = (arguments$) =>
+  new FunctionCall(arguments$);
+export const AssertKind$isFunctionCall = (value) =>
+  value instanceof FunctionCall;
+export const AssertKind$FunctionCall$arguments = (value) => value.arguments;
+export const AssertKind$FunctionCall$0 = (value) => value.arguments;
+
+export class OtherExpression extends $CustomType {
+  constructor(expression) {
+    super();
+    this.expression = expression;
+  }
+}
+export const AssertKind$OtherExpression = (expression) =>
+  new OtherExpression(expression);
+export const AssertKind$isOtherExpression = (value) =>
+  value instanceof OtherExpression;
+export const AssertKind$OtherExpression$expression = (value) =>
+  value.expression;
+export const AssertKind$OtherExpression$0 = (value) => value.expression;
+
+export class AssertedExpression extends $CustomType {
+  constructor(start, end, kind) {
+    super();
+    this.start = start;
+    this.end = end;
+    this.kind = kind;
+  }
+}
+export const AssertedExpression$AssertedExpression = (start, end, kind) =>
+  new AssertedExpression(start, end, kind);
+export const AssertedExpression$isAssertedExpression = (value) =>
+  value instanceof AssertedExpression;
+export const AssertedExpression$AssertedExpression$start = (value) =>
+  value.start;
+export const AssertedExpression$AssertedExpression$0 = (value) => value.start;
+export const AssertedExpression$AssertedExpression$end = (value) => value.end;
+export const AssertedExpression$AssertedExpression$1 = (value) => value.end;
+export const AssertedExpression$AssertedExpression$kind = (value) => value.kind;
+export const AssertedExpression$AssertedExpression$2 = (value) => value.kind;
+
+export class Literal extends $CustomType {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+}
+export const ExpressionKind$Literal = (value) => new Literal(value);
+export const ExpressionKind$isLiteral = (value) => value instanceof Literal;
+export const ExpressionKind$Literal$value = (value) => value.value;
+export const ExpressionKind$Literal$0 = (value) => value.value;
+
+export class Expression extends $CustomType {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+}
+export const ExpressionKind$Expression = (value) => new Expression(value);
+export const ExpressionKind$isExpression = (value) =>
+  value instanceof Expression;
+export const ExpressionKind$Expression$value = (value) => value.value;
+export const ExpressionKind$Expression$0 = (value) => value.value;
+
+export class Unevaluated extends $CustomType {}
+export const ExpressionKind$Unevaluated = () => new Unevaluated();
+export const ExpressionKind$isUnevaluated = (value) =>
+  value instanceof Unevaluated;

package/build/dev/javascript/gleeunit/gleeunit/internal/gleeunit_gleam_panic_ffi.erl

@@ -0,0 +1,49 @@
+-module(gleeunit_gleam_panic_ffi).
+-export([from_dynamic/1]).
+
+from_dynamic(#{
+  gleam_error := assert,
+  start := Start,
+  'end' := End,
+  expression_start := EStart
+} = E) ->
+    wrap(E, {assert, Start, End, EStart, assert_kind(E)});
+from_dynamic(#{
+  gleam_error := let_assert,
+  start := Start,
+  'end' := End,
+  pattern_start := PStart,
+  pattern_end := PEnd,
+  value := Value
+} = E) ->
+    wrap(E, {let_assert, Start, End, PStart, PEnd, Value});
+from_dynamic(#{gleam_error := panic} = E) ->
+    wrap(E, panic);
+from_dynamic(#{gleam_error := todo} = E) ->
+    wrap(E, todo);
+from_dynamic(_) ->
+    {error, nil}.
+
+assert_kind(#{kind := binary_operator, left := L, right := R, operator := O}) ->
+    {binary_operator, atom_to_binary(O), expression(L), expression(R)};
+assert_kind(#{kind := function_call, arguments := Arguments}) ->
+    {function_call, lists:map(fun expression/1, Arguments)};
+assert_kind(#{kind := expression, expression := Expression}) ->
+    {other_expression, expression(Expression)}.
+
+expression(#{start := S, 'end' := E, kind := literal, value := Value}) ->
+    {asserted_expression, S, E, {literal, Value}};
+expression(#{start := S, 'end' := E, kind := expression, value := Value}) ->
+    {asserted_expression, S, E, {expression, Value}};
+expression(#{start := S, 'end' := E, kind := unevaluated}) ->
+    {asserted_expression, S, E, unevaluated}.
+
+wrap(#{
+    gleam_error := _,
+    file := File,
+    message := Message,
+    module := Module,
+    function := Function,
+    line := Line
+}, Kind) ->
+    {ok, {gleam_panic, Message, File, Module, Function, Line, Kind}}.

package/build/dev/javascript/gleeunit/gleeunit/internal/gleeunit_gleam_panic_ffi.mjs

@@ -0,0 +1,91 @@
+import { Result$Ok, Result$Error, List$Empty, List$NonEmpty } from "../../gleam.mjs";
+import {
+  GleamPanic$GleamPanic,
+  PanicKind$Todo,
+  PanicKind$Panic,
+  PanicKind$LetAssert,
+  PanicKind$Assert,
+  AssertKind$BinaryOperator,
+  AssertKind$FunctionCall,
+  AssertKind$OtherExpression,
+  AssertedExpression$AssertedExpression,
+  ExpressionKind$Literal,
+  ExpressionKind$Expression,
+  ExpressionKind$Unevaluated,
+} from "./gleam_panic.mjs";
+
+export function from_dynamic(error) {
+  if (!(error instanceof globalThis.Error) || !error.gleam_error) {
+    return Result$Error(undefined);
+  }
+
+  if (error.gleam_error === "todo") {
+    return wrap(error, PanicKind$Todo());
+  }
+
+  if (error.gleam_error === "panic") {
+    return wrap(error, PanicKind$Panic());
+  }
+
+  if (error.gleam_error === "let_assert") {
+    let kind = PanicKind$LetAssert(
+      error.start,
+      error.end,
+      error.pattern_start,
+      error.pattern_end,
+      error.value,
+    );
+    return wrap(error, kind);
+  }
+
+  if (error.gleam_error === "assert") {
+    let kind = PanicKind$Assert(
+      error.start,
+      error.end,
+      error.expression_start,
+      assert_kind(error),
+    );
+    return wrap(error, kind);
+  }
+
+  return Result$Error(undefined);
+}
+
+function assert_kind(error) {
+  if (error.kind == "binary_operator") {
+    return AssertKind$BinaryOperator(
+      error.operator,
+      expression(error.left),
+      expression(error.right),
+    );
+  }
+
+  if (error.kind == "function_call") {
+    let list = List$Empty();
+    let i = error.arguments.length;
+    while (i--) {
+      list = List$NonEmpty(expression(error.arguments[i]), list);
+    }
+    return AssertKind$FunctionCall(list);
+  }
+
+  return AssertKind$OtherExpression(expression(error.expression));
+}
+
+function expression(data) {
+  const expression = AssertedExpression$AssertedExpression(data.start, data.end, undefined);
+  if (data.kind == "literal") {
+    expression.kind = ExpressionKind$Literal(data.value);
+  } else if (data.kind == "expression") {
+    expression.kind = ExpressionKind$Expression(data.value);
+  } else {
+    expression.kind = ExpressionKind$Unevaluated();
+  }
+  return expression;
+}
+
+function wrap(e, kind) {
+  return Result$Ok(
+    GleamPanic$GleamPanic(e.message, e.file, e.module, e.function, e.line, kind),
+  );
+}

package/build/dev/javascript/gleeunit/gleeunit/internal/reporting.mjs

@@ -0,0 +1,256 @@
+import * as $bit_array from "../../../gleam_stdlib/gleam/bit_array.mjs";
+import * as $dynamic from "../../../gleam_stdlib/gleam/dynamic.mjs";
+import * as $int from "../../../gleam_stdlib/gleam/int.mjs";
+import * as $io from "../../../gleam_stdlib/gleam/io.mjs";
+import * as $list from "../../../gleam_stdlib/gleam/list.mjs";
+import * as $option from "../../../gleam_stdlib/gleam/option.mjs";
+import * as $result from "../../../gleam_stdlib/gleam/result.mjs";
+import * as $string from "../../../gleam_stdlib/gleam/string.mjs";
+import { Ok, Error, toList, CustomType as $CustomType } from "../../gleam.mjs";
+import * as $gleam_panic from "../../gleeunit/internal/gleam_panic.mjs";
+import { read_file as read_file_text } from "../../gleeunit_ffi.mjs";
+
+export class State extends $CustomType {
+  constructor(passed, failed, skipped) {
+    super();
+    this.passed = passed;
+    this.failed = failed;
+    this.skipped = skipped;
+  }
+}
+export const State$State = (passed, failed, skipped) =>
+  new State(passed, failed, skipped);
+export const State$isState = (value) => value instanceof State;
+export const State$State$passed = (value) => value.passed;
+export const State$State$0 = (value) => value.passed;
+export const State$State$failed = (value) => value.failed;
+export const State$State$1 = (value) => value.failed;
+export const State$State$skipped = (value) => value.skipped;
+export const State$State$2 = (value) => value.skipped;
+
+export function new_state() {
+  return new State(0, 0, 0);
+}
+
+function bold(text) {
+  return ("\u{001b}[1m" + text) + "\u{001b}[22m";
+}
+
+function cyan(text) {
+  return ("\u{001b}[36m" + text) + "\u{001b}[39m";
+}
+
+function code_snippet(src, start, end) {
+  let _pipe = $result.try$(
+    $option.to_result(src, undefined),
+    (src) => {
+      return $result.try$(
+        $bit_array.slice(src, start, end - start),
+        (snippet) => {
+          return $result.try$(
+            $bit_array.to_string(snippet),
+            (snippet) => {
+              let snippet$1 = ((cyan(" code") + ": ") + snippet) + "\n";
+              return new Ok(snippet$1);
+            },
+          );
+        },
+      );
+    },
+  );
+  return $result.unwrap(_pipe, "");
+}
+
+function yellow(text) {
+  return ("\u{001b}[33m" + text) + "\u{001b}[39m";
+}
+
+export function test_skipped(state, module, function$) {
+  $io.print(((("\n" + module) + ".") + function$) + yellow(" skipped"));
+  return new State(state.passed, state.failed, state.skipped + 1);
+}
+
+function green(text) {
+  return ("\u{001b}[32m" + text) + "\u{001b}[39m";
+}
+
+export function test_passed(state) {
+  $io.print(green("."));
+  return new State(state.passed + 1, state.failed, state.skipped);
+}
+
+function red(text) {
+  return ("\u{001b}[31m" + text) + "\u{001b}[39m";
+}
+
+export function finished(state) {
+  let $ = state.failed;
+  if ($ === 0) {
+    let $1 = state.skipped;
+    if ($1 === 0) {
+      let $2 = state.passed;
+      if ($2 === 0) {
+        $io.println("\nNo tests found!");
+        return 1;
+      } else {
+        let message = ("\n" + $int.to_string(state.passed)) + " passed, no failures";
+        $io.println(green(message));
+        return 0;
+      }
+    } else {
+      let message = ((("\n" + $int.to_string(state.passed)) + " passed, 0 failures, ") + $int.to_string(
+        state.skipped,
+      )) + " skipped";
+      $io.println(yellow(message));
+      return 1;
+    }
+  } else {
+    let $1 = state.skipped;
+    if ($1 === 0) {
+      let message = ((("\n" + $int.to_string(state.passed)) + " passed, ") + $int.to_string(
+        state.failed,
+      )) + " failures";
+      $io.println(red(message));
+      return 1;
+    } else {
+      let message = ((((("\n" + $int.to_string(state.passed)) + " passed, ") + $int.to_string(
+        state.failed,
+      )) + " failures, ") + $int.to_string(state.skipped)) + " skipped";
+      $io.println(red(message));
+      return 1;
+    }
+  }
+}
+
+export function eunit_missing() {
+  let message = bold(red("Error")) + ": EUnit libraries not found.\n\nYour Erlang installation seems to be incomplete. If you installed Erlang using\na package manager ensure that you have installed the full Erlang\ndistribution instead of a stripped-down version.\n";
+  $io.print_error(message);
+  return new Error(undefined);
+}
+
+function grey(text) {
+  return ("\u{001b}[90m" + text) + "\u{001b}[39m";
+}
+
+function format_unknown(module, function$, error) {
+  return $string.concat(
+    toList([
+      grey((module + ".") + function$) + "\n",
+      "An unexpected error occurred:\n",
+      "\n",
+      ("  " + $string.inspect(error)) + "\n",
+    ]),
+  );
+}
+
+function inspect_value(value) {
+  let $ = value.kind;
+  if ($ instanceof $gleam_panic.Literal) {
+    return grey("literal");
+  } else if ($ instanceof $gleam_panic.Expression) {
+    let value$1 = $.value;
+    return $string.inspect(value$1);
+  } else {
+    return grey("unevaluated");
+  }
+}
+
+function assert_value(name, value) {
+  return ((cyan(name) + ": ") + inspect_value(value)) + "\n";
+}
+
+function assert_info(kind) {
+  if (kind instanceof $gleam_panic.BinaryOperator) {
+    let left = kind.left;
+    let right = kind.right;
+    return $string.concat(
+      toList([assert_value(" left", left), assert_value("right", right)]),
+    );
+  } else if (kind instanceof $gleam_panic.FunctionCall) {
+    let arguments$ = kind.arguments;
+    let _pipe = arguments$;
+    let _pipe$1 = $list.index_map(
+      _pipe,
+      (e, i) => {
+        let number = $string.pad_start($int.to_string(i), 5, " ");
+        return assert_value(number, e);
+      },
+    );
+    return $string.concat(_pipe$1);
+  } else {
+    return "";
+  }
+}
+
+function format_gleam_error(error, module, function$, src) {
+  let location = grey((error.file + ":") + $int.to_string(error.line));
+  let $ = error.kind;
+  if ($ instanceof $gleam_panic.Todo) {
+    return $string.concat(
+      toList([
+        ((bold(yellow("todo")) + " ") + location) + "\n",
+        ((((cyan(" test") + ": ") + module) + ".") + function$) + "\n",
+        ((cyan(" info") + ": ") + error.message) + "\n",
+      ]),
+    );
+  } else if ($ instanceof $gleam_panic.Panic) {
+    return $string.concat(
+      toList([
+        ((bold(red("panic")) + " ") + location) + "\n",
+        ((((cyan(" test") + ": ") + module) + ".") + function$) + "\n",
+        ((cyan(" info") + ": ") + error.message) + "\n",
+      ]),
+    );
+  } else if ($ instanceof $gleam_panic.LetAssert) {
+    let start = $.start;
+    let end = $.end;
+    let value = $.value;
+    return $string.concat(
+      toList([
+        ((bold(red("let assert")) + " ") + location) + "\n",
+        ((((cyan(" test") + ": ") + module) + ".") + function$) + "\n",
+        code_snippet(src, start, end),
+        ((cyan("value") + ": ") + $string.inspect(value)) + "\n",
+        ((cyan(" info") + ": ") + error.message) + "\n",
+      ]),
+    );
+  } else {
+    let start = $.start;
+    let end = $.end;
+    let kind = $.kind;
+    return $string.concat(
+      toList([
+        ((bold(red("assert")) + " ") + location) + "\n",
+        ((((cyan(" test") + ": ") + module) + ".") + function$) + "\n",
+        code_snippet(src, start, end),
+        assert_info(kind),
+        ((cyan(" info") + ": ") + error.message) + "\n",
+      ]),
+    );
+  }
+}
+
+function read_file(path) {
+  let $ = read_file_text(path);
+  if ($ instanceof Ok) {
+    let text = $[0];
+    return new Ok($bit_array.from_string(text));
+  } else {
+    return $;
+  }
+}
+
+export function test_failed(state, module, function$, error) {
+  let _block;
+  let $ = $gleam_panic.from_dynamic(error);
+  if ($ instanceof Ok) {
+    let error$1 = $[0];
+    let src = $option.from_result(read_file(error$1.file));
+    _block = format_gleam_error(error$1, module, function$, src);
+  } else {
+    _block = format_unknown(module, function$, error);
+  }
+  let message = _block;
+  $io.print("\n" + message);
+  return new State(state.passed, state.failed + 1, state.skipped);
+}