@discourse/types 0.0.2 → 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

@@ -33,13 +33,6 @@
     "types",
     "addon-main.cjs"
   ],
-  "typesVersions": {
-    "*": {
-      "*": [
-        "types/*"
-      ]
-    }
-  },
   "dependencies": {
     "@embroider/addon-shim": "^1.9.0",
     "@embroider/macros": "^1.16.12",
@@ -104,5 +97,13 @@
     "lint:js": "eslint . --cache",
     "lint:js:fix": "eslint . --fix",
     "start": "rollup --config --watch"
-  }
+  },
+  "__typesVersions": {
+    "*": {
+      "*": [
+        "types/*"
+      ]
+    }
+  },
+  "types": "index.d.ts"
 }

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

@@ -389,7 +389,10 @@
       "rsvp/index.js": "ember-source/rsvp/index.js"
     }
   },
-  "typesVersions": {
+  "packageManager": "pnpm@10.5.0",
+  "_originalVersion": "6.6.0",
+  "_versionPreviouslyCalculated": true,
+  "__typesVersions": {
     "*": {
       "types": [
         "types/stable"
@@ -399,7 +402,5 @@
       ]
     }
   },
-  "packageManager": "pnpm@10.5.0",
-  "_originalVersion": "6.6.0",
-  "_versionPreviouslyCalculated": true
+  "types": "types/stable/index.d.ts"
 }

package/external-types/ember__render-modifiers/index.d.ts

@@ -0,0 +1,52 @@
+declare module '@ember/render-modifiers/-private' {
+	import { ModifierLike } from '@glint/template';
+
+	export type RenderModifier<El extends Element, Args extends Array<any>> = InstanceType<
+	  ModifierLike<{
+	    Element: El;
+	    Args: {
+	      Positional: [callback: (element: El, args: Args) => unknown, ...callbackArgs: Args];
+	    };
+	  }>
+	>;
+
+}
+declare module '@ember/render-modifiers/modifiers/did-insert' {
+	import { RenderModifier } from '@ember/render-modifiers/-private'; const didInsert: abstract new <
+	  El extends Element,
+	  Args extends Array<any>
+	>() => RenderModifier<El, Args>;
+
+	export default didInsert;
+
+}
+declare module '@ember/render-modifiers/modifiers/did-update' {
+	import { RenderModifier } from '@ember/render-modifiers/-private'; const didUpdate: abstract new <
+	  El extends Element,
+	  Args extends Array<any>
+	>() => RenderModifier<El, Args>;
+
+	export default didUpdate;
+
+}
+declare module '@ember/render-modifiers/modifiers/will-destroy' {
+	import { RenderModifier } from '@ember/render-modifiers/-private'; const willDestroy: abstract new <
+	  El extends Element,
+	  Args extends Array<any>
+	>() => RenderModifier<El, Args>;
+
+	export default willDestroy;
+
+}
+declare module '@ember/render-modifiers/template-registry' {
+	import type didInsert from '@ember/render-modifiers/modifiers/did-insert';
+	import type didUpdate from '@ember/render-modifiers/modifiers/did-update';
+	import type willDestroy from '@ember/render-modifiers/modifiers/will-destroy';
+
+	export default interface RenderModifiersRegistry {
+	  'did-insert': typeof didInsert;
+	  'did-update': typeof didUpdate;
+	  'will-destroy': typeof willDestroy;
+	}
+
+}

package/external-types/{@ember__render-modifiers → ember__render-modifiers}/package.json

@@ -117,11 +117,12 @@
       "release": true
     }
   },
-  "typesVersions": {
+  "__typesVersions": {
     "*": {
       "*": [
         "types/*"
       ]
     }
-  }
-}
+  },
+  "types": "index.d.ts"
+}

package/external-types/ember__string/index.d.ts

@@ -0,0 +1,159 @@
+declare module '@ember/string' {
+	/**
+	 Returns the lowerCamelCase form of a string.
+	
+	 ```javascript
+	 import { camelize } from '@ember/string';
+	
+	 camelize('innerHTML');                   // 'innerHTML'
+	 camelize('action_name');                 // 'actionName'
+	 camelize('css-class-name');              // 'cssClassName'
+	 camelize('my favorite items');           // 'myFavoriteItems'
+	 camelize('My Favorite Items');           // 'myFavoriteItems'
+	 camelize('private-docs/owner-invoice');  // 'privateDocs/ownerInvoice'
+	 ```
+	
+	 @method camelize
+	 @param {String} str The string to camelize.
+	 @return {String} the camelized string.
+	 @public
+	 */
+	export function camelize(str: string): string;
+	
+	/**
+	 Returns the Capitalized form of a string
+	
+	 ```javascript
+	 import { capitalize } from '@ember/string';
+	
+	 capitalize('innerHTML')                 // 'InnerHTML'
+	 capitalize('action_name')               // 'Action_name'
+	 capitalize('css-class-name')            // 'Css-class-name'
+	 capitalize('my favorite items')         // 'My favorite items'
+	 capitalize('privateDocs/ownerInvoice'); // 'PrivateDocs/ownerInvoice'
+	 ```
+	
+	 @method capitalize
+	 @param {String} str The string to capitalize.
+	 @return {String} The capitalized string.
+	 @public
+	 */
+	export function capitalize(str: string): string;
+	
+	/**
+	 Returns the UpperCamelCase form of a string.
+	
+	 ```javascript
+	 import { classify } from '@ember/string';
+	
+	 classify('innerHTML');                   // 'InnerHTML'
+	 classify('action_name');                 // 'ActionName'
+	 classify('css-class-name');              // 'CssClassName'
+	 classify('my favorite items');           // 'MyFavoriteItems'
+	 classify('private-docs/owner-invoice');  // 'PrivateDocs/OwnerInvoice'
+	 ```
+	
+	 @method classify
+	 @param {String} str the string to classify
+	 @return {String} the classified string
+	 @public
+	 */
+	export function classify(str: string): string;
+	
+	/**
+	 Replaces underscores, spaces, or camelCase with dashes.
+	
+	 ```javascript
+	 import { dasherize } from '@ember/string';
+	
+	 dasherize('innerHTML');                // 'inner-html'
+	 dasherize('action_name');              // 'action-name'
+	 dasherize('css-class-name');           // 'css-class-name'
+	 dasherize('my favorite items');        // 'my-favorite-items'
+	 dasherize('privateDocs/ownerInvoice';  // 'private-docs/owner-invoice'
+	 ```
+	
+	 @method dasherize
+	 @param {String} str The string to dasherize.
+	 @return {String} the dasherized string.
+	 @public
+	 */
+	export function dasherize(str: string): string;
+	
+	/**
+	 Converts a camelized string into all lower case separated by underscores.
+	
+	 ```javascript
+	 import { decamelize } from '@ember/string';
+	
+	 decamelize('innerHTML');          // 'inner_html'
+	 decamelize('action_name');        // 'action_name'
+	 decamelize('css-class-name');     // 'css-class-name'
+	 decamelize('my favorite items');  // 'my favorite items'
+	 ```
+	
+	 @method decamelize
+	 @param {String} str The string to decamelize.
+	 @return {String} the decamelized string.
+	 @public
+	 */
+	export function decamelize(str: string): string;
+	
+	export function getString(name: string): string | undefined;
+	
+	export function getStrings(): {
+	    [key: string]: string;
+	};
+	
+	export function setStrings(strings: {
+	    [key: string]: string;
+	}): void;
+	
+	/**
+	 More general than decamelize. Returns the lower\_case\_and\_underscored
+	 form of a string.
+	
+	 ```javascript
+	 import { underscore } from '@ember/string';
+	
+	 underscore('innerHTML');                 // 'inner_html'
+	 underscore('action_name');               // 'action_name'
+	 underscore('css-class-name');            // 'css_class_name'
+	 underscore('my favorite items');         // 'my_favorite_items'
+	 underscore('privateDocs/ownerInvoice');  // 'private_docs/owner_invoice'
+	 ```
+	
+	 @method underscore
+	 @param {String} str The string to underscore.
+	 @return {String} the underscored string.
+	 @public
+	 */
+	export function underscore(str: string): string;
+	
+	/**
+	 Splits a string into separate units separated by spaces, eliminating any
+	 empty strings in the process. This is a convenience method for split that
+	 is mostly useful when applied to the `String.prototype`.
+	
+	 ```javascript
+	 import { w } from '@ember/string';
+	
+	 w("alpha beta gamma").forEach(function(key) {
+	 console.log(key);
+	 });
+	
+	 // > alpha
+	 // > beta
+	 // > gamma
+	 ```
+	
+	 @method w
+	 @param {String} str The string to split
+	 @return {Array} array containing the split strings
+	 @public
+	 */
+	export function w(str: string): string[];
+	
+	export { }
+
+}

package/external-types/{@ember__string → ember__string}/package.json

@@ -12,13 +12,6 @@
       "default": "./dist/index.js"
     }
   },
-  "typesVersions": {
-    "*": {
-      "*": [
-        "declarations/*"
-      ]
-    }
-  },
   "files": [
     "dist",
     "declarations",
@@ -63,5 +56,13 @@
     "start": "vite build --watch",
     "test": "cd tests && pnpm test",
     "test:types": "tsc --noEmit --emitDeclarationOnly false"
-  }
+  },
+  "__typesVersions": {
+    "*": {
+      "*": [
+        "declarations/*"
+      ]
+    }
+  },
+  "types": "index.d.ts"
 }