@discourse/types 0.0.1 → 2026.1.0-2709d36

package/external-types/ember-qunit/index.d.ts

@@ -0,0 +1,285 @@
+declare module 'ember-qunit' {
+	// Type definitions for ember-qunit 5.0
+	// Project: https://github.com/emberjs/ember-qunit#readme
+	// Definitions by: Dan Freeman <https://github.com/dfreeman>
+	//                 Chris Krycho <https://github.com/chriskrycho>
+	//                 James C. Davis <https://github.com/jamescdavis>
+	// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+	// Minimum TypeScript Version: 4.4
+
+	import EmberTestAdapter from '@ember/test/adapter';
+	import { Resolver } from '@ember/owner';
+	import { TestContext } from '@ember/test-helpers';
+
+	/**
+	 * Sets a Resolver globally which will be used to look up objects from each test's container.
+	 */
+	export function setResolver(resolver: Resolver): void;
+
+	/**
+	 * Options for configuring the test runner. Normally, you will not need to
+	 * customize this. It is exported primarily so that end user app code can name
+	 * it when passing it back to the framework.
+	 */
+	export interface SetupTestOptions {
+	  /**
+	   * The resolver to use when instantiating container-managed entities in the test.
+	   */
+	  resolver?: Resolver | undefined;
+	}
+
+	/**
+	 * Sets up acceptance tests.
+	 *
+	 * The `setupApplicationTest` function is used for all acceptance tests. It
+	 * is invoked in the callback scope of a QUnit module (aka "nested module").
+	 *
+	 * Once invoked, all subsequent hooks.beforeEach and test invocations will
+	 * have access to the following:
+	 * * `this.owner` - the owner object that been set on the test context.
+	 * * `this.pauseTest` and `this.resumeTest` - allow easy pausing/resuming of tests.
+	 * * `this.element` which returns the DOM element representing the application's root element.
+	 */
+	export function setupApplicationTest(
+	  hooks: NestedHooks,
+	  options?: SetupTestOptions
+	): void;
+
+	/**
+	 * Sets up tests that need to render snippets of templates.
+	 *
+	 * The setupRenderingTest method is used for tests that need to render
+	 * snippets of templates. It is also invoked in the callback scope of a
+	 * QUnit module (aka "nested module").
+	 *
+	 * Once invoked, all subsequent hooks.beforeEach and test invocations will
+	 * have access to the following:
+	 * * All of the methods / properties listed for `setupTest`
+	 * * this.render(...) - Renders the provided template snippet returning a
+	 * promise that resolves once rendering has completed
+	 * * An importable render function that de-sugars into this.render will be
+	 * the default output of blueprints
+	 * * this.element - Returns the native DOM element representing the element
+	 * that was rendered via this.render
+	 * * this.$(...) - When jQuery is present, executes a jQuery selector with
+	 * the current this.element as its root
+	 */
+	export function setupRenderingTest(
+	  hooks: NestedHooks,
+	  options?: SetupTestOptions
+	): void;
+
+	/**
+	 * Sets up tests that do not need to render snippets of templates.
+	 *
+	 * The `setupTest` method is used for all types of tests except for those
+	 * that need to render snippets of templates. It is invoked in the callback
+	 * scope of a QUnit module (aka "nested module").
+	 *
+	 * Once invoked, all subsequent hooks.beforeEach and test invocations will
+	 * have access to the following:
+	 * * this.owner - This exposes the standard "owner API" for the test environment.
+	 * * this.set / this.setProperties - Allows setting values on the test context.
+	 * * this.get / this.getProperties - Retrieves values from the test context.
+	 */
+	export function setupTest(hooks: NestedHooks, options?: SetupTestOptions): void;
+
+	export class QUnitAdapter extends EmberTestAdapter {}
+
+	export { module, test, skip, only, todo } from 'qunit';
+
+	interface QUnitStartOptions {
+	  /**
+	   * If `false` the test container will not be setup based on `devmode`,
+	   * `dockcontainer`, or `nocontainer` URL params.
+	   */
+	  setupTestContainer?: boolean | undefined;
+
+	  /**
+	   * If `false` tests will not be automatically started (you must run
+	   * `QUnit.start()` to kick them off).
+	   */
+	  startTests?: boolean | undefined;
+
+	  /**
+	   * If `false` the default Ember.Test adapter will not be updated.
+	   */
+	  setupTestAdapter?: boolean | undefined;
+
+	  /**
+	   * `false` opts out of the default behavior of setting `Ember.testing`
+	   * to `true` before all tests and back to `false` after each test will.
+	   */
+	  setupEmberTesting?: boolean | undefined;
+
+	  /**
+	   * If `false` test isolation validation will be disabled.
+	   */
+	  setupTestIsolationValidation?: boolean | undefined;
+	}
+
+	export function setupEmberOnerrorValidation(): void;
+
+	export function start(options?: QUnitStartOptions): void; global {
+	  // NOTE: disables `no-unnecessary-generics` inline because, unfortunately,
+	  // the design of Ember's test tooling (and indeed *QUnit's* test system)
+	  // requires that we allow users to update the type of the context of the
+	  // test. This is indeed strictly *wrong*! However, changing it will require
+	  // changing how Ember handles testing. See [the PR][pr] for further details.
+	  //
+	  // [pr]: https://github.com/DefinitelyTyped/DefinitelyTyped/pull/56494
+
+	  interface NestedHooks {
+	    /**
+	     * Runs after the last test. If additional tests are defined after the
+	     * module's queue has emptied, it will not run this hook again.
+	     */
+	    after<TC extends TestContext>(
+	      fn: (this: TC, assert: Assert) => void | Promise<void>
+	    ): void;
+
+	    /**
+	     * Runs after each test.
+	     */
+	    afterEach<TC extends TestContext>(
+	      fn: (this: TC, assert: Assert) => void | Promise<void>
+	    ): void;
+
+	    /**
+	     * Runs before the first test.
+	     */
+	    // SAFETY: this is just wildly, impossibly unsafe. QUnit cannot -- ever! --
+	    before<TC extends TestContext>(
+	      fn: (this: TC, assert: Assert) => void | Promise<void>
+	    ): void;
+
+	    /**
+	     * Runs before each test.
+	     */
+	    // SAFETY: this is just wildly, impossibly unsafe. QUnit cannot -- ever! --
+	    beforeEach<TC extends TestContext>(
+	      fn: (this: TC, assert: Assert) => void | Promise<void>
+	    ): void;
+	  }
+
+	  interface QUnit {
+	    /**
+	     * Adds a test to exclusively run, preventing all other tests from running.
+	     *
+	     * Use this method to focus your test suite on a specific test. QUnit.only
+	     * will cause any other tests in your suite to be ignored.
+	     *
+	     * Note, that if more than one QUnit.only is present only the first instance
+	     * will run.
+	     *
+	     * This is an alternative to filtering tests to run in the HTML reporter. It
+	     * is especially useful when you use a console reporter or in a codebase
+	     * with a large set of long running tests.
+	     *
+	     * @param name Title of unit being tested
+	     * @param callback Function to close over assertions
+	     */
+	    // SAFETY: this is just wildly, impossibly unsafe. QUnit cannot -- ever! --
+	    // provide this guarantee. However, it's also the only way to support TS
+	    // in tests in Ember until we move the community over entirely to using
+	    // `<template>` and local scope.
+	    only<TC extends TestContext>(
+	      name: string,
+	      callback: (this: TC, assert: Assert) => void | Promise<unknown>
+	    ): void;
+
+	    /**
+	     * Use this method to test a unit of code which is still under development (in a “todo” state).
+	     * The test will pass as long as one failing assertion is present.
+	     *
+	     * If all assertions pass, then the test will fail signaling that `QUnit.todo` should
+	     * be replaced by `QUnit.test`.
+	     *
+	     * @param name Title of unit being tested
+	     * @param callback Function to close over assertions
+	     */
+	    // SAFETY: this is just wildly, impossibly unsafe. QUnit cannot -- ever! --
+	    // provide this guarantee. However, it's also the only way to support TS
+	    // in tests in Ember until we move the community over entirely to using
+	    // `<template>` and local scope.
+	    todo<TC extends TestContext>(
+	      name: string,
+	      callback: (this: TC, assert: Assert) => void | Promise<unknown>
+	    ): void;
+
+	    /**
+	     * Adds a test like object to be skipped.
+	     *
+	     * Use this method to replace QUnit.test() instead of commenting out entire
+	     * tests.
+	     *
+	     * This test's prototype will be listed on the suite as a skipped test,
+	     * ignoring the callback argument and the respective global and module's
+	     * hooks.
+	     *
+	     * @param name Title of unit being tested
+	     * @param callback Function to close over assertions
+	     */
+	    // SAFETY: this is just wildly, impossibly unsafe. QUnit cannot -- ever! --
+	    // provide this guarantee. However, it's also the only way to support TS
+	    // in tests in Ember until we move the community over entirely to using
+	    // `<template>` and local scope.
+	    skip<TC extends TestContext>(
+	      name: string,
+	      callback?: (this: TC, assert: Assert) => void | Promise<unknown>
+	    ): void;
+	  }
+
+	  namespace QUnit {
+	    interface TestFunction {
+	      // SAFETY: this is just wildly, impossibly unsafe. QUnit cannot -- ever! --
+	      // provide this guarantee. However, it's also the only way to support TS
+	      // in tests in Ember until we move the community over entirely to using
+	      // `<template>` and local scope.
+	      <TC extends TestContext>(
+	        name: string,
+	        callback: (this: TC, assert: Assert) => void | Promise<unknown>
+	      ): void;
+	    }
+
+	    interface SkipFunction {
+	      <TC extends TestContext>(
+	        name: string,
+	        callback?: (this: TC, assert: Assert) => void | Promise<unknown>
+	      ): void;
+	    }
+
+	    interface TodoFunction {
+	      <TC extends TestContext>(
+	        name: string,
+	        callback?: (this: TC, assert: Assert) => void | Promise<unknown>
+	      ): void;
+	    }
+
+	    interface OnlyFunction {
+	      <TC extends TestContext>(
+	        name: string,
+	        callback: (this: TC, assert: Assert) => void | Promise<unknown>
+	      ): void;
+	    }
+
+	    interface EachFunction {
+	      <TC extends TestContext, T>(
+	        name: string,
+	        dataset: T[] | Record<string, T>,
+	        callback: (this: TC, assert: Assert, data: T) => void | Promise<unknown>
+	      ): void;
+	    }
+	  }
+	}
+
+}
+declare module 'ember-qunit/local-types' {
+	import 'ember-source/types';
+	import 'ember-source/types/preview';
+
+}
+declare module 'ember-qunit/test-loader' {
+	export function loadTests(): void;
+
+}

package/external-types/ember-qunit/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "ember-qunit",
+  "version": "9.0.4",
+  "description": "QUnit helpers for testing Ember.js applications",
+  "keywords": [
+    "ember-addon"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/emberjs/ember-qunit.git"
+  },
+  "license": "MIT",
+  "contributors": [
+    "Stefan Penner",
+    "Ryan Florence",
+    "Robert Jackson",
+    "Dan Gebhardt",
+    "Steve Calvert"
+  ],
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./types/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./addon-main.js": "./addon-main.cjs"
+  },
+  "files": [
+    "dist",
+    "types",
+    "addon-main.cjs"
+  ],
+  "dependencies": {
+    "@embroider/addon-shim": "^1.9.0",
+    "@embroider/macros": "^1.16.12",
+    "qunit-theme-ember": "^1.0.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.26.10",
+    "@babel/eslint-parser": "^7.27.0",
+    "@ember/test-helpers": "^3.0.3",
+    "@embroider/addon-dev": "^3.0.0",
+    "@glimmer/component": "^2.0.0",
+    "@rollup/plugin-babel": "^5.3.0",
+    "@tsconfig/ember": "^2.0.0",
+    "@types/qunit": "^2.19.12",
+    "@types/rsvp": "^4.0.4",
+    "concurrently": "^9.1.2",
+    "ember-source": "^5.0.0",
+    "eslint": "^8.52.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-disable-features": "^0.1.3",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "expect-type": "^0.16.0",
+    "prettier": "^2.8.8",
+    "qunit": "^2.24.1",
+    "rollup": "^4.2.0",
+    "typescript": "^4.9.5"
+  },
+  "peerDependencies": {
+    "@ember/test-helpers": ">=3.0.3",
+    "qunit": "^2.13.0"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "changelog": {
+    "repo": "emberjs/ember-qunit",
+    "labels": {
+      "breaking": ":boom: Breaking Change",
+      "enhancement": ":rocket: Enhancement",
+      "bug": ":bug: Bug Fix",
+      "documentation": ":memo: Documentation",
+      "internal": ":house: Internal"
+    }
+  },
+  "ember": {
+    "edition": "octane"
+  },
+  "ember-addon": {
+    "version": 2,
+    "type": "addon",
+    "main": "addon-main.cjs",
+    "app-js": {}
+  },
+  "volta": {
+    "extends": "../package.json"
+  },
+  "scripts": {
+    "build": "rollup --config",
+    "lint": "concurrently 'npm:lint:*(!fix)' --names 'lint:'",
+    "lint:fix": "concurrently 'npm:lint:*:fix' --names 'fix:'",
+    "lint:js": "eslint . --cache",
+    "lint:js:fix": "eslint . --fix",
+    "start": "rollup --config --watch"
+  },
+  "__typesVersions": {
+    "*": {
+      "*": [
+        "types/*"
+      ]
+    }
+  },
+  "types": "index.d.ts"
+}

package/external-types/ember-source/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Yehuda Katz, Tom Dale and Ember.js contributors
+
+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.