@discourse/types 0.0.0 → 0.0.2

package/external-types/ember-source/types/stable/@ember/array/lib/make-array.d.ts

@@ -0,0 +1,34 @@
+declare module '@ember/array/lib/make-array' {
+    /**
+     @module @ember/array
+    */
+    /**
+     Forces the passed object to be part of an array. If the object is already
+     an array, it will return the object. Otherwise, it will add the object to
+     an array. If object is `null` or `undefined`, it will return an empty array.
+
+     ```javascript
+     import { makeArray } from '@ember/array';
+     import ArrayProxy from '@ember/array/proxy';
+
+     makeArray();            // []
+     makeArray(null);        // []
+     makeArray(undefined);   // []
+     makeArray('lindsay');   // ['lindsay']
+     makeArray([1, 2, 42]);  // [1, 2, 42]
+
+     let proxy = ArrayProxy.create({ content: [] });
+
+     makeArray(proxy) === proxy;  // false
+     ```
+
+     @method makeArray
+     @static
+     @for @ember/array
+     @param {Object} obj the object
+     @return {Array}
+     @private
+     */
+    function makeArray<T, TT>(obj: T): T extends TT[] ? T : T extends null | undefined ? [] : [T]
+    export default makeArray;
+}

package/external-types/ember-source/types/stable/@ember/array/make.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/array/make' {
+    export { default } from "@ember/array/lib/make-array";
+}

package/external-types/ember-source/types/stable/@ember/array/mutable.d.ts

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

package/external-types/ember-source/types/stable/@ember/array/proxy.d.ts

@@ -0,0 +1,161 @@
+declare module '@ember/array/proxy' {
+    /**
+    @module @ember/array/proxy
+    */
+    import { PROPERTY_DID_CHANGE } from "@ember/-internals/metal";
+    import type { PropertyDidChange } from "@ember/-internals/metal";
+    import EmberObject from "@ember/object";
+    import EmberArray, { type NativeArray } from "@ember/array";
+    import MutableArray from "@ember/array/mutable";
+    import { type Tag, type Revision } from "@glimmer/validator";
+    /**
+      An ArrayProxy wraps any other object that implements `Array` and/or
+      `MutableArray,` forwarding all requests. This makes it very useful for
+      a number of binding use cases or other cases where being able to swap
+      out the underlying array is useful.
+
+      A simple example of usage:
+
+      ```javascript
+      import { A } from '@ember/array';
+      import ArrayProxy from '@ember/array/proxy';
+
+      let pets = ['dog', 'cat', 'fish'];
+      let ap = ArrayProxy.create({ content: A(pets) });
+
+      ap.get('firstObject');                        // 'dog'
+      ap.set('content', ['amoeba', 'paramecium']);
+      ap.get('firstObject');                        // 'amoeba'
+      ```
+
+      This class can also be useful as a layer to transform the contents of
+      an array, as they are accessed. This can be done by overriding
+      `objectAtContent`:
+
+      ```javascript
+      import { A } from '@ember/array';
+      import ArrayProxy from '@ember/array/proxy';
+
+      let pets = ['dog', 'cat', 'fish'];
+      let ap = ArrayProxy.create({
+          content: A(pets),
+          objectAtContent: function(idx) {
+              return this.get('content').objectAt(idx).toUpperCase();
+          }
+      });
+
+      ap.get('firstObject'); // . 'DOG'
+      ```
+
+      When overriding this class, it is important to place the call to
+      `_super` *after* setting `content` so the internal observers have
+      a chance to fire properly:
+
+      ```javascript
+      import { A } from '@ember/array';
+      import ArrayProxy from '@ember/array/proxy';
+
+      export default ArrayProxy.extend({
+        init() {
+          this.set('content', A(['dog', 'cat', 'fish']));
+          this._super(...arguments);
+        }
+      });
+      ```
+
+      @class ArrayProxy
+      @extends EmberObject
+      @uses MutableArray
+      @public
+    */
+    interface ArrayProxy<T> extends MutableArray<T> {
+        /**
+          The content array. Must be an object that implements `Array` and/or
+          `MutableArray.`
+      
+          @property content
+          @type EmberArray
+          @public
+        */
+        content: T[] | EmberArray<T> | NativeArray<T> | null;
+        /**
+          The array that the proxy pretends to be. In the default `ArrayProxy`
+          implementation, this and `content` are the same. Subclasses of `ArrayProxy`
+          can override this property to provide things like sorting and filtering.
+      
+          @property arrangedContent
+          @public
+        */
+        arrangedContent: EmberArray<T> | null;
+        /**
+          Should actually retrieve the object at the specified index from the
+          content. You can override this method in subclasses to transform the
+          content item to something new.
+      
+          This method will only be called if content is non-`null`.
+      
+          @method objectAtContent
+          @param {Number} idx The index to retrieve.
+          @return {Object} the value or undefined if none found
+          @public
+        */
+        objectAtContent(idx: number): T | undefined;
+        /**
+          Should actually replace the specified objects on the content array.
+          You can override this method in subclasses to transform the content item
+          into something new.
+      
+          This method will only be called if content is non-`null`.
+      
+          @method replaceContent
+          @param {Number} idx The starting index
+          @param {Number} amt The number of items to remove from the content.
+          @param {Array} objects Optional array of objects to insert.
+          @return {void}
+          @public
+        */
+        replaceContent(idx: number, amt: number, objects?: T[]): void;
+        create(init: {
+            content: Array<T>;
+        }): ArrayProxy<T>;
+    }
+    class ArrayProxy<T> extends EmberObject implements PropertyDidChange {
+        /** @internal */
+        _objectsDirtyIndex: number;
+        /** @internal */
+        _objects: null | T[];
+        /** @internal */
+        _lengthDirty: boolean;
+        /** @internal */
+        _length: number;
+        /** @internal */
+        _arrangedContent: EmberArray<T> | null;
+        /** @internal */
+        _arrangedContentIsUpdating: boolean;
+        /** @internal */
+        _arrangedContentTag: Tag | null;
+        /** @internal */
+        _arrangedContentRevision: Revision | null;
+        /** @internal */
+        _lengthTag: Tag | null;
+        /** @internal */
+        _arrTag: Tag | null;
+        init(props: object | undefined): void;
+        [PROPERTY_DID_CHANGE](): void;
+        willDestroy(): void;
+        content: T[] | EmberArray<T> | NativeArray<T> | null;
+        arrangedContent: EmberArray<T> | null;
+        replace(idx: number, amt: number, objects?: T[]): void;
+        objectAt(idx: number): T | undefined;
+        get length(): number;
+        set length(value: number);
+        _updateArrangedContentArray(arrangedContent: EmberArray<T> | null): void;
+        _addArrangedContentArrayObserver(arrangedContent: EmberArray<T> | null): void;
+        _removeArrangedContentArrayObserver(): void;
+        _arrangedContentArrayWillChange(): void;
+        _arrangedContentArrayDidChange(_proxy: unknown, idx: number, removedCnt: number, addedCnt: number): void;
+        _invalidate(): void;
+        _revalidate(): void;
+    }
+    export default ArrayProxy;
+}

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

@@ -0,0 +1,41 @@
+declare module '@ember/canary-features' {
+    /**
+      Set `EmberENV.FEATURES` in your application's `config/environment.js` file
+      to enable canary features in your application.
+
+      See the [feature flag guide](https://guides.emberjs.com/release/configuring-ember/feature-flags/)
+      for more details.
+
+      @module @ember/canary-features
+      @public
+    */
+    export const DEFAULT_FEATURES: {};
+    /**
+      The hash of enabled Canary features. Add to this, any canary features
+      before creating your application.
+
+      @class FEATURES
+      @static
+      @since 1.1.0
+      @public
+    */
+    export const FEATURES: {
+        [feature: string]: boolean;
+    };
+    /**
+      Determine whether the specified `feature` is enabled. Used by Ember's
+      build tools to exclude experimental features from beta/stable builds.
+
+      You can define the following configuration options:
+
+      * `EmberENV.ENABLE_OPTIONAL_FEATURES` - enable any features that have not been explicitly
+        enabled/disabled.
+
+      @method isEnabled
+      @param {String} feature The feature to check
+      @return {Boolean}
+      @since 1.1.0
+      @public
+    */
+    export function isEnabled(feature: string): boolean;
+}

package/external-types/ember-source/types/stable/@ember/component/helper.d.ts

@@ -0,0 +1,3 @@
+declare module '@ember/component/helper' {
+    export { Helper as default, helper, type FunctionBasedHelper, type FunctionBasedHelperInstance, } from "@ember/-internals/glimmer";
+}

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

@@ -0,0 +1,126 @@
+declare module '@ember/component' {
+    /**
+      @module @ember/component
+      @public
+     */
+    export { setComponentTemplate, getComponentTemplate } from "@glimmer/manager";
+    export { Component as default, Input, Textarea } from "@ember/-internals/glimmer";
+    export { componentCapabilities as capabilities, setComponentManager, } from "@ember/-internals/glimmer";
+    /**
+     * Assigns a TemplateFactory to a component class.
+     *
+     * @method setComponentTemplate
+     * @static
+     * @for @ember/component
+     * @public
+     *
+     * ```js
+     * import Component from '@glimmer/component';
+     * import { hbs } from 'ember-cli-htmlbars';
+     * import { setComponentTemplate } from '@ember/component';
+     *
+     * export default class Demo extends Component {
+     *   // ...
+     * }
+     *
+     * setComponentTemplate(hbs`
+     *  <div>my template</div>
+     * `, Demo);
+     * ```
+     *
+     * @param {TemplateFactory} templateFactory
+     * @param {object} componentDefinition
+     */
+    /**
+     * Returns the TemplateFactory associated with a component
+     *
+     * @method getComponentTemplate
+     * @static
+     * @for @ember/component
+     * @public
+     *
+     * ```js
+     * import Component from '@glimmer/component';
+     * import { hbs } from 'ember-cli-htmlbars';
+     * import { getComponentTemplate } from '@ember/component';
+     *
+     * export default class Demo extends Component {
+     *   // ...
+     * }
+     *
+     * let theTemplateFactory = getTemplateFactory(Demo)
+     * ```
+     *
+     * @param {object} componentDefinition
+     * @returns {TemplateFactory}
+     */
+    /**
+     * Tell the VM how manage a type of object / class when encountered
+     * via component-invocation.
+     *
+     * A Component Manager, must implement this interface:
+     * - static create()
+     * - createComponent()
+     * - updateComponent()
+     * - destroyComponent()
+     * - getContext()
+     *
+     * @method setComponentManager
+     * @static
+     * @for @ember/component
+     * @public
+     *
+     *
+     * After a component manager is registered via `setComponentManager`,
+     *
+     * ```js
+     * import { StateNode } from 'xstate';
+     * import ComponentManager from './-private/statechart-manager';
+     *
+     * setComponentManager((owner) => ComponentManager.create(owner), StateNode.prototype);
+     * ```
+     *
+     * Instances of the class can be used as component.
+     * No need to extend from `@glimmer/component`.
+     *
+     * ```js
+     * // app/components/my-component.js
+     * import { createMachine } from 'xstate';
+     *
+     * export default createMachine({ ... });
+     * ```
+     * ```hbs
+     * {{!-- app/templates/application.hbs}}
+     * <MyComponent />
+     * ```
+     *
+     * @param {(owner: Owner) => import('@glimmer/interfaces').ComponentManager} managerFactory
+     * @param {object} object that will be managed by the return value of `managerFactory`
+     *
+     */
+    /**
+     * Tells Glimmer what capabilities a Component Manager will have
+     *
+     * ```js
+     * import { capabilities } from '@ember/component';
+     *
+     * export class MyComponentManager {
+     *   capabilities = capabilities('3.13', {
+     *     // capabilities listed here
+     *   })
+     * }
+     * ```
+     *
+     *
+     * For a full list of capabilities, their defaults, and how they are used, see [@glimmer/manager](https://github.com/glimmerjs/glimmer-vm/blob/4f1bef0d9a8a3c3ebd934c5b6e09de4c5f6e4468/packages/%40glimmer/manager/lib/public/component.ts#L26)
+     *
+     *
+     * @method capabilities
+     * @static
+     * @for @ember/component
+     * @public
+     * @param {'3.13'} managerApiVersion
+     * @param {Parameters<import('@ember/-internals/glimmer').componentCapabilities>[1]} options
+     *
+     */
+}

package/external-types/ember-source/types/stable/@ember/component/template-only.d.ts

@@ -0,0 +1,47 @@
+declare module '@ember/component/template-only' {
+    /**
+      @module @ember/component/template-only
+      @public
+    */
+    /**
+      This utility function is used to declare a given component has no backing class. When the rendering engine detects this it
+      is able to perform a number of optimizations. Templates that are associated with `templateOnly()` will be rendered _as is_
+      without adding a wrapping `<div>` (or any of the other element customization behaviors of [@ember/component](/ember/release/classes/Component)).
+      Specifically, this means that the template will be rendered as "outer HTML".
+
+      In apps, this method will usually be inserted by build-time tooling the handles converting `.hbs` files into component Javascript modules and
+      would not be directly written by the application author.
+
+      Addons may want to use this method directly to ensure that a template-only component is treated consistently in all Ember versions (Ember versions
+      before 4.0 have a "template-only-glimmer-components" optional feature that causes a standalone `.hbs` file to be interpreted differently).
+
+      @example
+
+      ```js
+      import templateOnly from '@ember/component/template-only';
+
+      export default templateOnly();
+      ```
+
+      @public
+      @static
+      @method templateOnly
+      @param {String} moduleName the module name that the template only component represents, this will be used for debugging purposes
+      @for @ember/component/template-only
+      @category EMBER_GLIMMER_SET_COMPONENT_TEMPLATE
+    */
+    import { type Opaque } from "@ember/-internals/utility-types";
+    /**
+     * Template-only components have no backing class instance, so `this` in their
+     * templates is null. This means that you can only reference passed in arguments
+     * (e.g. `{{@arg}}`).
+     */
+    export interface TemplateOnlyComponent<S = unknown> extends Opaque<S> {
+    }
+    /**
+     * A convenience alias for {@link TemplateOnlyComponent}
+     */
+    export type TOC<S> = TemplateOnlyComponent<S>;
+    const templateOnly: <S>(moduleName?: string, name?: string) => TemplateOnlyComponent<S>;
+    export default templateOnly;
+}