@discourse/types 0.0.0 → 0.0.2

package/external-types/ember-source/types/stable/@ember/template-compiler/lib/template.d.ts

@@ -0,0 +1,215 @@
+declare module '@ember/template-compiler/lib/template' {
+    import { type TemplateOnlyComponent } from "@ember/component/template-only";
+    type ComponentClass = abstract new (...args: any[]) => object;
+    /**
+     * All possible options passed to `template()` may specify a `moduleName`.
+     */
+    export interface BaseTemplateOptions {
+        moduleName?: string;
+        /**
+         * Whether the template should be treated as a strict-mode template. Defaults
+         * to `true`.
+         */
+        strictMode?: boolean;
+    }
+    /**
+     * When using `template` in a class, you call it in a `static` block and pass
+     * the class as the `component` option.
+     *
+     * ```ts
+     * class MyComponent extends Component {
+     *   static {
+     *     template('{{this.greeting}}, {{@place}}!',
+     *       { component: this },
+     *       // explicit or implicit option goes here
+     *     );
+     *   }
+     * }
+     * ```
+     *
+     * For the full explicit form, see {@linkcode ExplicitClassOptions}. For the
+     * full implicit form, see {@linkcode ImplicitClassOptions}.
+     */
+    export interface BaseClassTemplateOptions<C extends ComponentClass> extends BaseTemplateOptions {
+        component: C;
+    }
+    /**
+     * When using `template` outside of a class (i.e. a "template-only component"), you can pass
+     * a `scope` option that explicitly provides the lexical scope for the template.
+     *
+     * This is called the "explicit form".
+     *
+     * ```ts
+     * const greeting = 'Hello';
+     * const HelloWorld = template('{{greeting}} World!', { scope: () => ({ greeting }) });
+     * ```
+     */
+    export interface ExplicitTemplateOnlyOptions extends BaseTemplateOptions {
+        scope(): Record<string, unknown>;
+    }
+    /**
+     * When using `template` *inside* a class (see
+     * {@linkcode BaseClassTemplateOptions}), you can pass a `scope` option that
+     * explicitly provides the lexical scope for the template, just like a template-only
+     * component (see {@linkcode ExplicitTemplateOnlyOptions}).
+     *
+     * ```ts
+     * class MyComponent extends Component {
+     *   static {
+     *     template('{{this.greeting}}, {{@place}}!',
+     *       { component: this },
+     *       // explicit or implicit option goes here
+     *     );
+     *   }
+     * }
+     * ```
+     *
+     * ## The Scope Function's `instance` Parameter
+     *
+     * However, the explicit `scope` function in a *class* also takes an `instance` option
+     * that provides access to the component's instance.
+     *
+     * Once it's supported in Handlebars, this will make it possible to represent private
+     * fields when using the explicit form.
+     *
+     * ```ts
+     * class MyComponent extends Component {
+     *   static {
+     *     template('{{this.#greeting}}, {{@place}}!',
+     *       { component: this },
+     *       scope: (instance) => ({ '#greeting': instance.#greeting }),
+     *     );
+     *   }
+     * }
+     * ```
+     */
+    export interface ExplicitClassOptions<C extends ComponentClass> extends BaseClassTemplateOptions<C> {
+        scope(instance?: InstanceType<C>): Record<string, unknown>;
+    }
+    /**
+     * The *implicit* form of the `template` function takes an `eval` option that
+     * allows the runtime compiler to evaluate local template variables without
+     * needing to maintain an explicit list of the local variables used in the
+     * template scope.
+     *
+     * The eval options *must* be passed in the following form:
+     *
+     * ```ts
+     * {
+     *   eval() { return eval(arguments[0]) }
+     * }
+     * ```
+     *
+     * ## Requirements of the `eval` Option
+     *
+     * **The syntactic form presented above is the only form you should use when
+     * passing an `eval` option.**
+     *
+     * This is _required_ if you want your code to be compatible with the
+     * compile-time implementation of `@ember/template-compiler`. While the runtime
+     * compiler offers a tiny bit of additional wiggle room, you still need to follow
+     * very strict rules.
+     *
+     * We don't recommend trying to memorize the rules. Instead, we recommend using
+     * the snippet presented above and supported by the compile-time implementation.
+     *
+     * ### The Technical Requirements of the `eval` Option
+     *
+     * The `eval` function is passed a single parameter that is a JavaScript
+     * identifier. This will be extended in the future to support private fields.
+     *
+     * Since keywords in JavaScript are contextual (e.g. `await` and `yield`), the
+     * parameter might be a keyword. The `@ember/template-compiler/runtime` expects
+     * the function to throw a `SyntaxError` if the identifier name is not valid in
+     * the current scope. (The direct `eval` function takes care of this out of the
+     * box.)
+     *
+     * Requirements:
+     *
+     * 1. The `eval` method must receive its parameter as `arguments[0]`, which
+     *    ensures that the variable name passed to `eval()` is not shadowed by the
+     *    function's parameter name.
+     * 2. The `eval` option must be a function or concise method, and not an arrow.
+     *    This is because arrows do not have their own `arguments`, which breaks
+     *    (1).
+     * 3. The `eval` method must call "*direct* `eval`", and not an alias of `eval`.
+     *    Direct `eval` evaluates the code in the scope it was called from, while
+     *    aliased versions of `eval` (including `new Function`) evaluate the code in
+     *    the global scope.
+     * 4. The `eval` method must return the result of calling "direct `eval`".
+     *
+     * The easiest way to achieve these requirements is to use the exact syntax
+     * presented above. This is *also* the only way to be compatible
+     *
+     * ## Rationale
+     *
+     * This is useful for two reasons:
+     *
+     * 1. This form is a useful _intermediate_ form for the compile-time toolchain.
+     *    It allows the content-tag preprocessor to convert the `<template>` syntax
+     *    into valid JavaScript without needing to involve full-fledged lexical
+     *    analysis.
+     * 2. This form is a convenient form for manual prototyping when using the
+     *    runtime compiler directly. While it requires some extra typing relative to
+     *    `<template>`, it's a mechanical 1:1 transformation of the syntax.
+     *
+     * In practice, implementations that use a runtime compiler (for example, a
+     * playground running completely in the browser) should probably use the
+     * `content-tag` preprocessor to convert the template into the implicit form,
+     * and then rely on `@ember/template-compiler/runtime` to evaluate the template.
+     */
+    export interface ImplicitEvalOption {
+        eval(): unknown;
+    }
+    /**
+     * When using `template` outside of a class (i.e. a "template-only component"), you can pass
+     * an `eval` option that _implicitly_ provides the lexical scope for the template.
+     *
+     * This is called the "implicit form".
+     *
+     * ```ts
+     * const greeting = 'Hello';
+     * const HelloWorld = template('{{greeting}} World!', {
+     *   eval() { return arguments[0] }
+     * });
+     * ```
+     *
+     * For more details on the requirements of the `eval` option, see {@linkcode ImplicitEvalOption}.
+     */
+    export type ImplicitTemplateOnlyOptions = BaseTemplateOptions & ImplicitEvalOption;
+    /**
+     * When using `template` inside of a class, you can pass an `eval` option that
+     * _implicitly_ provides the lexical scope for the template, just as you can
+     * with a {@linkcode ImplicitTemplateOnlyOptions | template-only component}.
+     *
+     * This is called the "implicit form".
+     *
+     * ```ts
+     * class MyComponent extends Component {
+     *   static {
+     *     template('{{this.greeting}}, {{@place}}!',
+     *       { component: this },
+     *       eval() { return arguments[0] }
+     *     );
+     *   }
+     * }
+     * ```
+     *
+     * ## Note  on Private Fields
+     *
+     * The current implementation of `@ember/template-compiler` does not support
+     * private fields, but once the Handlebars parser adds support for private field
+     * syntax and it's implemented in the Glimmer compiler, the implicit form should
+     * be able to support them.
+     */
+    export type ImplicitClassOptions<C extends ComponentClass> = BaseClassTemplateOptions<C> & ImplicitEvalOption;
+    export function template(
+     templateString: string,
+     options?: ExplicitTemplateOnlyOptions | ImplicitTemplateOnlyOptions
+    ): TemplateOnlyComponent;
+    export function template<C extends ComponentClass>(
+     templateString: string,
+     options: ExplicitClassOptions<C> | ImplicitClassOptions<C> | BaseClassTemplateOptions<C>
+    ): C;
+    export {};
+}

package/external-types/ember-source/types/stable/@ember/template-compiler/lib/types.d.ts

@@ -0,0 +1,44 @@
+declare module '@ember/template-compiler/lib/types' {
+    import type { ASTPluginEnvironment, builders, PrecompileOptions, PrecompileOptionsWithLexicalScope } from "@glimmer/syntax";
+    export type Builders = typeof builders;
+    export type PluginFunc = NonNullable<NonNullable<PrecompileOptionsWithLexicalScope["plugins"]>["ast"]>[number];
+    export type LexicalScope = NonNullable<PrecompileOptionsWithLexicalScope["lexicalScope"]>;
+    interface Plugins {
+        ast: PluginFunc[];
+    }
+    export interface EmberPrecompileOptions extends PrecompileOptions {
+        isProduction?: boolean;
+        moduleName?: string;
+        plugins?: Plugins;
+        lexicalScope?: LexicalScope;
+        /**
+         * This supports template blocks defined in class bodies.
+         *
+         * Manual form:
+         *
+         * ```ts
+         * class MyComponent {
+         *   static {
+         *     template(templateContent, {
+         *       component: this,
+         *       eval: () => eval(arguments[0])
+         *     })
+         *   }
+         * }
+         * ```
+         *
+         * GJS form (compiled to the manual form via `content-tag`):
+         *
+         * ```ts
+         * class MyComponent {
+         *   <template>Template Content</template>
+         * }
+         * ```
+         */
+        component?: object;
+        eval?: (value: string) => unknown;
+        scope?: () => Record<string, unknown>;
+    }
+    export type EmberASTPluginEnvironment = ASTPluginEnvironment & EmberPrecompileOptions;
+    export {};
+}

package/external-types/ember-source/types/stable/@ember/template-compiler/runtime.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/template-compiler/runtime' {
+    export * from "@ember/template-compiler/lib/runtime";
+}

package/external-types/ember-source/types/stable/@ember/template-factory/index.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/template-factory' {
+    export { templateFactory as createTemplateFactory } from "@glimmer/opcode-compiler";
+}

package/external-types/ember-source/types/stable/@ember/test/adapter.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/test/adapter' {
+    export { Adapter as default } from "ember-testing";
+}

package/external-types/ember-source/types/stable/@ember/test/index.d.ts

@@ -0,0 +1,10 @@
+declare module '@ember/test' {
+    import type * as EmberTesting from "ember-testing";
+    export let registerAsyncHelper: (typeof EmberTesting.Test)["registerAsyncHelper"];
+    export let registerHelper: (typeof EmberTesting.Test)["registerHelper"];
+    export let registerWaiter: (typeof EmberTesting.Test)["registerWaiter"];
+    export let unregisterHelper: (typeof EmberTesting.Test)["unregisterHelper"];
+    export let unregisterWaiter: (typeof EmberTesting.Test)["unregisterWaiter"];
+    export let _impl: typeof EmberTesting | undefined;
+    export function registerTestImplementation(impl: typeof EmberTesting): void;
+}

package/external-types/ember-source/types/stable/@ember/utils/index.d.ts

@@ -0,0 +1,9 @@
+declare module '@ember/utils' {
+    export { default as isNone } from "@ember/utils/lib/is_none";
+    export { default as isBlank } from "@ember/utils/lib/is_blank";
+    export { default as isEmpty } from "@ember/utils/lib/is_empty";
+    export { default as isPresent } from "@ember/utils/lib/is_present";
+    export { default as isEqual } from "@ember/utils/lib/is-equal";
+    export { default as typeOf } from "@ember/utils/lib/type-of";
+    export { default as compare } from "@ember/utils/lib/compare";
+}

package/external-types/ember-source/types/stable/@ember/utils/lib/compare.d.ts

@@ -0,0 +1,54 @@
+declare module '@ember/utils/lib/compare' {
+    type Compare = -1 | 0 | 1;
+    /**
+     @module @ember/utils
+    */
+    /**
+     Compares two javascript values and returns:
+
+      - -1 if the first is smaller than the second,
+      - 0 if both are equal,
+      - 1 if the first is greater than the second.
+
+      ```javascript
+      import { compare } from '@ember/utils';
+
+      compare('hello', 'hello');  // 0
+      compare('abc', 'dfg');      // -1
+      compare(2, 1);              // 1
+      ```
+
+     If the types of the two objects are different precedence occurs in the
+     following order, with types earlier in the list considered `<` types
+     later in the list:
+
+      - undefined
+      - null
+      - boolean
+      - number
+      - string
+      - array
+      - object
+      - instance
+      - function
+      - class
+      - date
+
+      ```javascript
+      import { compare } from '@ember/utils';
+
+      compare('hello', 50);       // 1
+      compare(50, 'hello');       // -1
+      ```
+
+     @method compare
+     @for @ember/utils
+     @static
+     @param {Object} v First value to compare
+     @param {Object} w Second value to compare
+     @return {Number} -1 if v < w, 0 if v = w and 1 if v > w.
+     @public
+    */
+    export default function compare<T>(v: T, w: T): Compare;
+    export {};
+}

package/external-types/ember-source/types/stable/@ember/utils/lib/is-equal.d.ts

@@ -0,0 +1,52 @@
+declare module '@ember/utils/lib/is-equal' {
+    /**
+     @module @ember/utils
+    */
+    /**
+      Compares two objects, returning true if they are equal.
+
+      ```javascript
+      import { isEqual } from '@ember/utils';
+
+      isEqual('hello', 'hello');                   // true
+      isEqual(1, 2);                               // false
+      ```
+
+      `isEqual` is a more specific comparison than a triple equal comparison.
+      It will call the `isEqual` instance method on the objects being
+      compared, allowing finer control over when objects should be considered
+      equal to each other.
+
+      ```javascript
+      import { isEqual } from '@ember/utils';
+      import EmberObject from '@ember/object';
+
+      let Person = EmberObject.extend({
+        isEqual(other) { return this.ssn == other.ssn; }
+      });
+
+      let personA = Person.create({name: 'Muhammad Ali', ssn: '123-45-6789'});
+      let personB = Person.create({name: 'Cassius Clay', ssn: '123-45-6789'});
+
+      isEqual(personA, personB); // true
+      ```
+
+      Due to the expense of array comparisons, collections will never be equal to
+      each other even if each of their items are equal to each other.
+
+      ```javascript
+      import { isEqual } from '@ember/utils';
+
+      isEqual([4, 2], [4, 2]);                     // false
+      ```
+
+      @method isEqual
+      @for @ember/utils
+      @static
+      @param {Object} a first object to compare
+      @param {Object} b second object to compare
+      @return {Boolean}
+      @public
+    */
+    export default function isEqual(a: unknown, b: unknown): boolean;
+}

package/external-types/ember-source/types/stable/@ember/utils/lib/is_blank.d.ts

@@ -0,0 +1,32 @@
+declare module '@ember/utils/lib/is_blank' {
+    /**
+     @module @ember/utils
+    */
+    /**
+      A value is blank if it is empty or a whitespace string.
+
+      ```javascript
+      import { isBlank } from '@ember/utils';
+
+      isBlank(null);            // true
+      isBlank(undefined);       // true
+      isBlank('');              // true
+      isBlank([]);              // true
+      isBlank('\n\t');          // true
+      isBlank('  ');            // true
+      isBlank({});              // false
+      isBlank('\n\t Hello');    // false
+      isBlank('Hello world');   // false
+      isBlank([1,2,3]);         // false
+      ```
+
+      @method isBlank
+      @static
+      @for @ember/utils
+      @param {Object} obj Value to test
+      @return {Boolean}
+      @since 1.5.0
+      @public
+    */
+    export default function isBlank(obj: unknown): boolean;
+}

package/external-types/ember-source/types/stable/@ember/utils/lib/is_empty.d.ts

@@ -0,0 +1,38 @@
+declare module '@ember/utils/lib/is_empty' {
+    /**
+     @module @ember/utils
+    */
+    /**
+      Verifies that a value is `null` or `undefined`, an empty string, or an empty
+      array.
+
+      Constrains the rules on `isNone` by returning true for empty strings and
+      empty arrays.
+
+      If the value is an object with a `size` property of type number, it is used
+      to check emptiness.
+
+      ```javascript
+      isEmpty(null);             // true
+      isEmpty(undefined);        // true
+      isEmpty('');               // true
+      isEmpty([]);               // true
+      isEmpty({ size: 0});       // true
+      isEmpty({});               // false
+      isEmpty('Adam Hawkins');   // false
+      isEmpty([0,1,2]);          // false
+      isEmpty('\n\t');           // false
+      isEmpty('  ');             // false
+      isEmpty({ size: 1 })       // false
+      isEmpty({ size: () => 0 }) // false
+      ```
+
+      @method isEmpty
+      @static
+      @for @ember/utils
+      @param {Object} obj Value to test
+      @return {Boolean}
+      @public
+    */
+    export default function isEmpty(obj: unknown): boolean;
+}

package/external-types/ember-source/types/stable/@ember/utils/lib/is_none.d.ts

@@ -0,0 +1,26 @@
+declare module '@ember/utils/lib/is_none' {
+    /**
+     @module @ember/utils
+    */
+    /**
+      Returns true if the passed value is null or undefined. This avoids errors
+      from JSLint complaining about use of ==, which can be technically
+      confusing.
+
+      ```javascript
+      isNone(null);          // true
+      isNone(undefined);     // true
+      isNone('');            // false
+      isNone([]);            // false
+      isNone(function() {}); // false
+      ```
+
+      @method isNone
+      @static
+      @for @ember/utils
+      @param {Object} obj Value to test
+      @return {Boolean}
+      @public
+    */
+    export default function isNone(obj: any): obj is null | undefined;
+}

package/external-types/ember-source/types/stable/@ember/utils/lib/is_present.d.ts

@@ -0,0 +1,35 @@
+declare module '@ember/utils/lib/is_present' {
+    /**
+     @module @ember/utils
+    */
+    /**
+      A value is present if it not `isBlank`.
+
+      ```javascript
+      isPresent(null);            // false
+      isPresent(undefined);       // false
+      isPresent('');              // false
+      isPresent('  ');            // false
+      isPresent('\n\t');          // false
+      isPresent([]);              // false
+      isPresent({ length: 0 });   // false
+      isPresent(false);           // true
+      isPresent(true);            // true
+      isPresent('string');        // true
+      isPresent(0);               // true
+      isPresent(function() {});   // true
+      isPresent({});              // true
+      isPresent('\n\t Hello');    // true
+      isPresent([1, 2, 3]);       // true
+      ```
+
+      @method isPresent
+      @static
+      @for @ember/utils
+      @param {Object} obj Value to test
+      @return {Boolean}
+      @since 1.8.0
+      @public
+    */
+    export default function isPresent<T>(obj: T | null | undefined): obj is T;
+}

package/external-types/ember-source/types/stable/@ember/utils/lib/type-of.d.ts

@@ -0,0 +1,68 @@
+declare module '@ember/utils/lib/type-of' {
+    export type TypeName = "undefined" | "null" | "string" | "number" | "boolean" | "function" | "array" | "regexp" | "date" | "filelist" | "class" | "instance" | "error" | "object";
+    /**
+     @module @ember/utils
+    */
+    /**
+      Returns a consistent type for the passed object.
+
+      Use this instead of the built-in `typeof` to get the type of an item.
+      It will return the same result across all browsers and includes a bit
+      more detail. Here is what will be returned:
+
+          | Return Value  | Meaning                                              |
+          |---------------|------------------------------------------------------|
+          | 'string'      | String primitive or String object.                   |
+          | 'number'      | Number primitive or Number object.                   |
+          | 'boolean'     | Boolean primitive or Boolean object.                 |
+          | 'null'        | Null value                                           |
+          | 'undefined'   | Undefined value                                      |
+          | 'function'    | A function                                           |
+          | 'array'       | An instance of Array                                 |
+          | 'regexp'      | An instance of RegExp                                |
+          | 'date'        | An instance of Date                                  |
+          | 'filelist'    | An instance of FileList                              |
+          | 'class'       | An Ember class (created using EmberObject.extend())  |
+          | 'instance'    | An Ember object instance                             |
+          | 'error'       | An instance of the Error object                      |
+          | 'object'      | A JavaScript object not inheriting from EmberObject  |
+
+      Examples:
+
+      ```javascript
+      import { A } from '@ember/array';
+      import { typeOf } from '@ember/utils';
+      import EmberObject from '@ember/object';
+
+      typeOf();                       // 'undefined'
+      typeOf(null);                   // 'null'
+      typeOf(undefined);              // 'undefined'
+      typeOf('michael');              // 'string'
+      typeOf(new String('michael'));  // 'string'
+      typeOf(101);                    // 'number'
+      typeOf(new Number(101));        // 'number'
+      typeOf(true);                   // 'boolean'
+      typeOf(new Boolean(true));      // 'boolean'
+      typeOf(A);                      // 'function'
+      typeOf(A());                    // 'array'
+      typeOf([1, 2, 90]);             // 'array'
+      typeOf(/abc/);                  // 'regexp'
+      typeOf(new Date());             // 'date'
+      typeOf(event.target.files);     // 'filelist'
+      typeOf(EmberObject.extend());   // 'class'
+      typeOf(EmberObject.create());   // 'instance'
+      typeOf(new Error('teamocil'));  // 'error'
+
+      // 'normal' JavaScript object
+      typeOf({ a: 'b' });             // 'object'
+      ```
+
+      @method typeOf
+      @for @ember/utils
+      @param item the item to check
+      @return {String} the type
+      @public
+      @static
+    */
+    export default function typeOf(item: unknown): TypeName;
+}

package/external-types/ember-source/types/stable/@ember/version/index.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/version' {
+    export { default as VERSION } from "ember/version";
+}

package/external-types/ember-source/types/stable/@glimmer/env/index.d.ts

@@ -0,0 +1,4 @@
+declare module '@glimmer/env' {
+    export const DEBUG = false;
+    export const CI = false;
+}