@gjsify/console 0.0.1 → 0.0.3

package/test.node.mjs

@@ -0,0 +1,308 @@
+// ../../../node_modules/@girs/gjs/gjs.js
+var imports = globalThis.imports || {};
+
+// ../../gjs/unit/lib/esm/index.js
+import nodeAssert from "assert";
+var mainloop = globalThis?.imports?.mainloop;
+var countTestsOverall = 0;
+var countTestsFailed = 0;
+var countTestsIgnored = 0;
+var runtime = "";
+var RED = "\x1B[31m";
+var GREEN = "\x1B[32m";
+var BLUE = "\x1B[34m";
+var GRAY = "\x1B[90m";
+var RESET = "\x1B[39m";
+var print = globalThis.print || console.log;
+var MatcherFactory = class {
+  constructor(actualValue, positive, negated) {
+    this.actualValue = actualValue;
+    this.positive = positive;
+    if (negated) {
+      this.not = negated;
+    } else {
+      this.not = new MatcherFactory(actualValue, !positive, this);
+    }
+  }
+  not;
+  triggerResult(success, msg) {
+    if (success && !this.positive || !success && this.positive) {
+      ++countTestsFailed;
+      throw new Error(msg);
+    }
+  }
+  to(callback) {
+    this.triggerResult(
+      callback(this.actualValue),
+      `      Expected callback to validate`
+    );
+  }
+  toBe(expectedValue) {
+    this.triggerResult(
+      this.actualValue === expectedValue,
+      `      Expected values to match using ===
+      Expected: ${expectedValue} (${typeof expectedValue})
+      Actual: ${this.actualValue} (${typeof this.actualValue})`
+    );
+  }
+  toEqual(expectedValue) {
+    this.triggerResult(
+      this.actualValue == expectedValue,
+      `      Expected values to match using ==
+      Expected: ${expectedValue} (${typeof expectedValue})
+      Actual: ${this.actualValue} (${typeof this.actualValue})`
+    );
+  }
+  toEqualArray(expectedValue) {
+    let success = Array.isArray(this.actualValue) && Array.isArray(expectedValue) && this.actualValue.length === expectedValue.length;
+    for (let i = 0; i < this.actualValue.length; i++) {
+      const actualVal = this.actualValue[i];
+      const expectedVal = expectedValue[i];
+      success = actualVal == expectedVal;
+      if (!success)
+        break;
+    }
+    this.triggerResult(
+      success,
+      `      Expected array items to match using ==
+      Expected: ${expectedValue} (${typeof expectedValue})
+      Actual: ${this.actualValue} (${typeof this.actualValue})`
+    );
+  }
+  toMatch(expectedValue) {
+    if (typeof this.actualValue.match !== "function") {
+      throw new Error(`You can not use toMatch on type ${typeof this.actualValue}`);
+    }
+    this.triggerResult(
+      !!this.actualValue.match(expectedValue),
+      "      Expected values to match using regular expression\n      Expression: " + expectedValue + "\n      Actual: " + this.actualValue
+    );
+  }
+  toBeDefined() {
+    this.triggerResult(
+      typeof this.actualValue !== "undefined",
+      `      Expected value to be defined`
+    );
+  }
+  toBeUndefined() {
+    this.triggerResult(
+      typeof this.actualValue === "undefined",
+      `      Expected value to be undefined`
+    );
+  }
+  toBeNull() {
+    this.triggerResult(
+      this.actualValue === null,
+      `      Expected value to be null`
+    );
+  }
+  toBeTruthy() {
+    this.triggerResult(
+      this.actualValue,
+      `      Expected value to be truthy`
+    );
+  }
+  toBeFalsy() {
+    this.triggerResult(
+      !this.actualValue,
+      `      Expected value to be falsy`
+    );
+  }
+  toContain(needle) {
+    this.triggerResult(
+      this.actualValue instanceof Array && this.actualValue.indexOf(needle) !== -1,
+      `      Expected ` + this.actualValue + ` to contain ` + needle
+    );
+  }
+  toBeLessThan(greaterValue) {
+    this.triggerResult(
+      this.actualValue < greaterValue,
+      `      Expected ` + this.actualValue + ` to be less than ` + greaterValue
+    );
+  }
+  toBeGreaterThan(smallerValue) {
+    this.triggerResult(
+      this.actualValue > smallerValue,
+      `      Expected ` + this.actualValue + ` to be greater than ` + smallerValue
+    );
+  }
+  toBeCloseTo(expectedValue, precision) {
+    const shiftHelper = Math.pow(10, precision);
+    this.triggerResult(
+      Math.round(this.actualValue * shiftHelper) / shiftHelper === Math.round(expectedValue * shiftHelper) / shiftHelper,
+      `      Expected ` + this.actualValue + ` with precision ` + precision + ` to be close to ` + expectedValue
+    );
+  }
+  toThrow(ErrorType) {
+    let errorMessage = "";
+    let didThrow = false;
+    let typeMatch = true;
+    try {
+      this.actualValue();
+      didThrow = false;
+    } catch (e) {
+      errorMessage = e.message || "";
+      didThrow = true;
+      if (ErrorType) {
+        typeMatch = e instanceof ErrorType;
+      }
+    }
+    const functionName = this.actualValue.name || typeof this.actualValue === "function" ? "[anonymous function]" : this.actualValue.toString();
+    this.triggerResult(
+      didThrow,
+      `      Expected ${functionName} to ${this.positive ? "throw" : "not throw"} an exception ${!this.positive && errorMessage ? `, but an error with the message "${errorMessage}" was thrown` : ""}`
+    );
+    if (ErrorType) {
+      this.triggerResult(
+        typeMatch,
+        `      Expected Error type '${ErrorType.name}', but the error is not an instance of it`
+      );
+    }
+  }
+};
+var describe = async function(moduleName, callback) {
+  print("\n" + moduleName);
+  await callback();
+  beforeEachCb = null;
+  afterEachCb = null;
+};
+var beforeEachCb;
+var afterEachCb;
+var it = async function(expectation, callback) {
+  try {
+    if (typeof beforeEachCb === "function") {
+      await beforeEachCb();
+    }
+    await callback();
+    if (typeof afterEachCb === "function") {
+      await afterEachCb();
+    }
+    print(`  ${GREEN}\u2714${RESET} ${GRAY}${expectation}${RESET}`);
+  } catch (e) {
+    print(`  ${RED}\u274C${RESET} ${GRAY}${expectation}${RESET}`);
+    print(`${RED}${e.message}${RESET}`);
+    if (e.stack)
+      print(e.stack);
+  }
+};
+var expect = function(actualValue) {
+  ++countTestsOverall;
+  const expecter = new MatcherFactory(actualValue, true);
+  return expecter;
+};
+var assert = function(success, message) {
+  ++countTestsOverall;
+  if (!success) {
+    ++countTestsFailed;
+  }
+  nodeAssert(success, message);
+};
+assert.strictEqual = function(actual, expected, message) {
+  ++countTestsOverall;
+  try {
+    nodeAssert.strictEqual(actual, expected, message);
+  } catch (error) {
+    ++countTestsFailed;
+    throw error;
+  }
+};
+assert.throws = function(promiseFn, ...args) {
+  ++countTestsOverall;
+  let error;
+  try {
+    promiseFn();
+  } catch (e) {
+    error = e;
+  }
+  if (!error)
+    ++countTestsFailed;
+  nodeAssert.throws(() => {
+    if (error)
+      throw error;
+  }, args[0], args[1]);
+};
+assert.deepStrictEqual = function(actual, expected, message) {
+  ++countTestsOverall;
+  try {
+    nodeAssert.deepStrictEqual(actual, expected, message);
+  } catch (error) {
+    ++countTestsFailed;
+    throw error;
+  }
+};
+var runTests = async function(namespaces) {
+  for (const subNamespace in namespaces) {
+    const namespace = namespaces[subNamespace];
+    if (typeof namespace === "function") {
+      await namespace();
+    } else if (typeof namespace === "object") {
+      await runTests(namespace);
+    }
+  }
+};
+var printResult = () => {
+  if (countTestsIgnored) {
+    print(`
+${BLUE}\u2714 ${countTestsIgnored} ignored test${countTestsIgnored > 1 ? "s" : ""}${RESET}`);
+  }
+  if (countTestsFailed) {
+    print(`
+${RED}\u274C ${countTestsFailed} of ${countTestsOverall} tests failed${RESET}`);
+  } else {
+    print(`
+${GREEN}\u2714 ${countTestsOverall} completed${RESET}`);
+  }
+};
+var getRuntime = async () => {
+  if (runtime && runtime !== "Unknown") {
+    return runtime;
+  }
+  if (globalThis.Deno?.version?.deno) {
+    return "Deno " + globalThis.Deno?.version?.deno;
+  } else {
+    let process = globalThis.process;
+    if (!process) {
+      try {
+        process = await import("process");
+      } catch (error) {
+        console.error(error);
+        console.warn(error.message);
+        runtime = "Unknown";
+      }
+    }
+    if (process?.versions?.gjs) {
+      runtime = "Gjs " + process.versions.gjs;
+    } else if (process?.versions?.node) {
+      runtime = "Node.js " + process.versions.node;
+    }
+  }
+  return runtime || "Unknown";
+};
+var printRuntime = async () => {
+  const runtime2 = await getRuntime();
+  print(`
+Running on ${runtime2}`);
+};
+var run = async (namespaces) => {
+  printRuntime().then(async () => {
+    return runTests(namespaces).then(() => {
+      printResult();
+      print();
+      mainloop?.quit();
+    });
+  });
+  mainloop?.run();
+};
+
+// src/index.spec.ts
+import console2 from "console";
+var index_spec_default = async () => {
+  await describe("Default import", async () => {
+    await it("should be an object", async () => {
+      expect(console2 instanceof Object).toBeTruthy();
+    });
+  });
+};
+
+// src/test.mts
+run({ testSuite: index_spec_default });

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "module": "ESNext",
+    "types": ["node"],
+    "target": "ESNext",
+    "experimentalDecorators": true,
+    "outDir": "lib",
+    "rootDir": "src",
+    "composite": true,
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true
+  },
+  "skipLibCheck": true,
+  "allowJs": true,
+  "checkJs": false,
+  "reflection": false,
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/test.mts", "src/**/*.spec.ts"]
+}

package/tsconfig.types.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "emitDeclarationOnly": true,
+    "declarationDir": "lib/types",
+  },
+  "exclude": ["src/test.ts", "src/test.mts", "src/**/*.spec.ts", "src/**/*.spec.mts"]
+}

package/.testem.json

@@ -1,14 +0,0 @@
-{
-    "launchers": {
-        "node": {
-            "command": "npm test"
-        }
-    },
-    "src_files": [
-        "./**/*.js"
-    ],
-    "before_tests": "npm run build",
-    "on_exit": "rm test/static/bundle.js",
-    "test_page": "test/static/index.html",
-    "launch_in_dev": ["node", "phantomjs"]
-}

package/.travis.yml

@@ -1,11 +0,0 @@
-language: node_js
-node_js:
-  - "stable"
-  - "12"
-  - "11"
-  - "10"
-  - "8"
-  - "6"
-  - "4"
-  - "0.12"
-  - "0.10"

package/CHANGELOG.md

@@ -1,10 +0,0 @@
-# console-browserify change log
-
-All notable changes to this project will be documented in this file.
-
-This project adheres to [Semantic Versioning](http://semver.org/).
-
-## 1.2.0
-* Move to the browserify org.
-* Remove `date-now` dependency. ([@jakepusateri](https://github.com/jakepusateri) in [#10](https://github.com/browserify/console-browserify/pull/10))
-* Fix memory leak in `time`/`timeEnd`. ([@maxnordlund](https://github.com/maxnordlund) in [#11](https://github.com/browserify/console-browserify/pull/11))

package/LICENCE

@@ -1,19 +0,0 @@
-Copyright (c) 2012 Raynos.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

package/index.js

@@ -1,108 +0,0 @@
-/*
-  ┌─────────────┐
-  │   Missing   │
-  └─────────────┘
-  console.group
-  console.groupCollapsed
-  console.groupEnd()
-  no Console constructor
-*/
-
-/*global window, global*/
-var util = require("util")
-var assert = require("assert")
-function now() { return new Date().getTime() }
-
-var slice = Array.prototype.slice
-var console
-var times = {}
-
-if (typeof global !== "undefined" && global.console) {
-    console = global.console
-} else if (typeof window !== "undefined" && window.console) {
-    console = window.console
-} else if (typeof print === "function" && typeof printerr === "function") {
-    // gjs runtime
-    console = {
-        log: print,
-        warn: printerr,
-    }
-} else {
-    console = {}
-}
-
-var functions = [
-    [log, "log"],
-    [info, "info"],
-    [debug, "debug"],
-    [warn, "warn"],
-    [error, "error"],
-    [time, "time"],
-    [timeEnd, "timeEnd"],
-    [trace, "trace"],
-    [dir, "dir"],
-    [consoleAssert, "assert"]
-]
-
-function log() {}
-
-function info() {
-    console.log.apply(console, arguments)
-}
-
-function warn() {
-    console.log.apply(console, arguments)
-}
-
-function debug() {
-    console.log.apply(console, arguments)
-}
-
-function error() {
-    console.warn.apply(console, arguments)
-}
-
-function time(label) {
-    times[label] = now()
-}
-
-function timeEnd(label) {
-    var time = times[label]
-    if (!time) {
-        throw new Error("No such label: " + label)
-    }
-
-    delete times[label]
-    var duration = now() - time
-    console.log(label + ": " + duration + "ms")
-}
-
-function trace() {
-    var err = new Error()
-    err.name = "Trace"
-    err.message = util.format.apply(null, arguments)
-    console.error(err.stack)
-}
-
-function dir(object) {
-    console.log(util.inspect(object) + "\n")
-}
-
-function consoleAssert(expression) {
-    if (!expression) {
-        var arr = slice.call(arguments, 1)
-        assert.ok(false, util.format.apply(null, arr))
-    }
-}
-
-for (var i = 0; i < functions.length; i++) {
-    var tuple = functions[i]
-    var f = tuple[0]
-    var name = tuple[1]
-
-    if (!console[name]) {
-        console[name] = f
-    }
-}
-
-module.exports = console

package/test/index.js

@@ -1,67 +0,0 @@
-var console = require("../index")
-var test = require("tape")
-
-if (typeof window !== "undefined" && !window.JSON) {
-    window.JSON = require("jsonify")
-}
-
-test("console has expected methods", function (assert) {
-    assert.ok(console.log)
-    assert.ok(console.info)
-    assert.ok(console.warn)
-    assert.ok(console.dir)
-    assert.ok(console.time, "time")
-    assert.ok(console.timeEnd, "timeEnd")
-    assert.ok(console.trace, "trace")
-    assert.ok(console.assert)
-
-    assert.end()
-})
-
-test("invoke console.log", function (assert) {
-    console.log("test-log")
-
-    assert.end()
-})
-
-test("invoke console.info", function (assert) {
-    console.info("test-info")
-
-    assert.end()
-})
-
-test("invoke console.warn", function (assert) {
-    console.warn("test-warn")
-    
-    assert.end()
-})
-
-test("invoke console.time", function (assert) {
-    console.time("label")
-
-    assert.end()
-})
-
-test("invoke console.trace", function (assert) {
-    console.trace("test-trace")
-
-    assert.end()
-})
-
-test("invoke console.assert", function (assert) {
-    console.assert(true)
-
-    assert.end()
-})
-
-test("invoke console.dir", function (assert) {
-    console.dir("test-dir")
-
-    assert.end()
-})
-
-test("invoke console.timeEnd", function (assert) {
-    console.timeEnd("label")
-
-    assert.end()
-})

package/test/static/index.html

@@ -1,12 +0,0 @@
-<!doctype html>
-<html>
-<head>
-    <meta http-equiv="x-ua-compatible" content="IE=8" >
-    <title>TAPE Example</title>
-    <script src="/testem.js"></script>
-    <script src="test-adapter.js"></script>
-    <script src="bundle.js"></script>
-</head>
-<body>
-</body>
-</html>

package/test/static/test-adapter.js

@@ -1,53 +0,0 @@
-(function () {
-    var Testem = window.Testem
-    var regex = /^((?:not )?ok) (\d+) (.+)$/
-
-    Testem.useCustomAdapter(tapAdapter)
-
-    function tapAdapter(socket){
-        var results = {
-            failed: 0
-            , passed: 0
-            , total: 0
-            , tests: []
-        }
-
-        socket.emit('tests-start')
-
-        Testem.handleConsoleMessage = function(msg){
-            var m = msg.match(regex)
-            if (m) {
-                var passed = m[1] === 'ok'
-                var test = {
-                    passed: passed ? 1 : 0,
-                    failed: passed ? 0 : 1,
-                    total: 1,
-                    id: m[2],
-                    name: m[3],
-                    items: []
-                }
-
-                if (passed) {
-                    results.passed++
-                } else {
-                    console.error("failure", m)
-
-                    results.failed++
-                }
-
-                results.total++
-
-                // console.log("emitted test", test)
-                socket.emit('test-result', test)
-                results.tests.push(test)
-            } else if (msg === '# ok' || msg.match(/^# tests \d+/)){
-                // console.log("emitted all test")
-                socket.emit('all-test-results', results)
-            }
-
-            // return false if you want to prevent the console message from
-            // going to the console
-            // return false
-        }
-    }
-}())