@gjsify/querystring 0.0.4 → 0.1.0

package/test.node.js

@@ -1,231 +0,0 @@
-// ../../gjs/unit/dist/index.cjs
-import { versions } from "process";
-var _a;
-var mainloop = (_a = globalThis == null ? void 0 : globalThis.imports) == null ? void 0 : _a.mainloop;
-var countTestsOverall = 0;
-var countTestsFailed = 0;
-var print = globalThis.print || console.log;
-var MatcherFactory = class {
-  constructor(actualValue, positive, withOpposite = true) {
-    this.actualValue = actualValue;
-    this.positive = positive;
-    if (withOpposite) {
-      this.not = new MatcherFactory(actualValue, !positive, false);
-    }
-  }
-  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 ===\n      Expected: " + expectedValue + "\n      Actual: " + this.actualValue
-    );
-  }
-  toEqual(expectedValue) {
-    this.triggerResult(
-      this.actualValue == expectedValue,
-      "      Expected values to match using ==\n      Expected: " + expectedValue + "\n      Actual: " + 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) {
-    var 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() {
-    let errorMessage = "";
-    var didThrow = false;
-    try {
-      this.actualValue();
-      didThrow = false;
-    } catch (e) {
-      errorMessage = e.message || "";
-      didThrow = true;
-    }
-    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` : ""}`
-    );
-  }
-};
-var describe = async function(moduleName, callback) {
-  print("\n" + moduleName);
-  await callback();
-};
-var it = async function(expectation, callback) {
-  try {
-    await callback();
-    print("  \x1B[32m\u2714\x1B[39m \x1B[90m" + expectation + "\x1B[39m");
-  } catch (e) {
-    print("  \x1B[31m\u274C\x1B[39m \x1B[90m" + expectation + "\x1B[39m");
-    print("\x1B[31m" + e.message + "\x1B[39m");
-  }
-};
-var expect = function(actualValue) {
-  ++countTestsOverall;
-  var expecter = new MatcherFactory(actualValue, true);
-  return expecter;
-};
-var runTests = async function(namespaces) {
-  for (var subNamespace in namespaces) {
-    const namespace = namespaces[subNamespace];
-    if (typeof namespace === "function") {
-      await namespace();
-    } else if (typeof namespace === "object") {
-      await runTests(namespace);
-    }
-  }
-};
-var printResult = () => {
-  if (countTestsFailed) {
-    print("\n\x1B[31m\u274C " + countTestsFailed + " of " + countTestsOverall + " tests failed\x1B[39m");
-  } else {
-    print("\n\x1B[32m\u2714 " + countTestsOverall + " completed\x1B[39m");
-  }
-};
-var printRuntime = () => {
-  if (versions.gjs) {
-    print(`Running on Gjs ${versions.gjs}`);
-  } else if (versions.node) {
-    print(`Running on Node.js ${versions.node}`);
-  } else {
-    print(`Running on unknown runtime`);
-  }
-};
-var run = function(namespaces) {
-  printRuntime();
-  runTests(namespaces).then(() => {
-    printResult();
-    print();
-    mainloop == null ? void 0 : mainloop.quit();
-  });
-  mainloop == null ? void 0 : mainloop.run();
-};
-
-// src/index.spec.ts
-import * as qs from "querystring";
-var index_spec_default = async () => {
-  await describe("querystring", async () => {
-    await it("performs basic parsing", async () => {
-      expect(qs.parse("id=918854443121279438895193").id).toBe("918854443121279438895193");
-    });
-  });
-  await it("test stringifying invalid surrogate pair throws URIError", async () => {
-    expect(() => {
-      qs.stringify({ foo: "\uDC00" });
-    }).toThrow();
-    try {
-      qs.stringify({ foo: "\uDC00" });
-    } catch (error) {
-      expect(error instanceof URIError).toBeTruthy();
-    }
-  });
-  await it("test stringifying coerce numbers to string", async () => {
-    expect("foo=0").toBe(qs.stringify({ foo: 0 }));
-    expect("foo=0").toBe(qs.stringify({ foo: -0 }));
-    expect("foo=3").toBe(qs.stringify({ foo: 3 }));
-    expect("foo=-72.42").toBe(qs.stringify({ foo: -72.42 }));
-    expect("foo=").toBe(qs.stringify({ foo: NaN }));
-    expect("foo=").toBe(qs.stringify({ foo: Infinity }));
-  });
-  await it("test stringifying nested", async () => {
-    const f = qs.stringify({
-      a: "b",
-      q: qs.stringify({
-        x: "y",
-        y: "z"
-      })
-    });
-    expect(f).toBe("a=b&q=x%3Dy%26y%3Dz");
-  });
-  await it("test stringifying nested in colon", async () => {
-    const f = qs.stringify({
-      a: "b",
-      q: qs.stringify({
-        x: "y",
-        y: "z"
-      }, ";", ":")
-    }, ";", ":");
-    expect(f).toBe("a:b;q:x%3Ay%3By%3Az");
-  });
-  await it("test stringifying empty string", async () => {
-    expect(qs.stringify()).toBe("");
-    expect(qs.stringify(0)).toBe("");
-    expect(qs.stringify([])).toBe("");
-    expect(qs.stringify(null)).toBe("");
-    expect(qs.stringify(true)).toBe("");
-  });
-};
-
-// src/test.ts
-run({ testSuite: index_spec_default });

package/test.node.mjs

@@ -1,353 +0,0 @@
-// ../../../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 _MatcherFactory {
-  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 * as qs from "querystring";
-var index_spec_default = async () => {
-  await describe("querystring", async () => {
-    await it("performs basic parsing", async () => {
-      expect(qs.parse("id=918854443121279438895193").id).toBe("918854443121279438895193");
-    });
-  });
-  await it("test stringifying invalid surrogate pair throws URIError", async () => {
-    expect(() => {
-      qs.stringify({ foo: "\uDC00" });
-    }).toThrow();
-    try {
-      qs.stringify({ foo: "\uDC00" });
-    } catch (error) {
-      expect(error instanceof URIError).toBeTruthy();
-    }
-  });
-  await it("test stringifying coerce numbers to string", async () => {
-    expect("foo=0").toBe(qs.stringify({ foo: 0 }));
-    expect("foo=0").toBe(qs.stringify({ foo: -0 }));
-    expect("foo=3").toBe(qs.stringify({ foo: 3 }));
-    expect("foo=-72.42").toBe(qs.stringify({ foo: -72.42 }));
-    expect("foo=").toBe(qs.stringify({ foo: NaN }));
-    expect("foo=").toBe(qs.stringify({ foo: Infinity }));
-  });
-  await it("test stringifying nested", async () => {
-    const f = qs.stringify({
-      a: "b",
-      q: qs.stringify({
-        x: "y",
-        y: "z"
-      })
-    });
-    expect(f).toBe("a=b&q=x%3Dy%26y%3Dz");
-  });
-  await it("test stringifying nested in colon", async () => {
-    const f = qs.stringify({
-      a: "b",
-      q: qs.stringify({
-        x: "y",
-        y: "z"
-      }, ";", ":")
-    }, ";", ":");
-    expect(f).toBe("a:b;q:x%3Ay%3By%3Az");
-  });
-  await it("test stringifying empty string", async () => {
-    expect(qs.stringify()).toBe("");
-    expect(qs.stringify(0)).toBe("");
-    expect(qs.stringify([])).toBe("");
-    expect(qs.stringify(null)).toBe("");
-    expect(qs.stringify(true)).toBe("");
-  });
-};
-
-// src/test.mts
-run({ testSuite: index_spec_default });

package/tsconfig.types.json

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