@discourse/types 0.0.1 → 0.0.2

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

@@ -0,0 +1,203 @@
+declare module '@glimmer/tracking' {
+    export { tracked, cached } from "@ember/-internals/metal";
+    /**
+      In order to tell Ember a value might change, we need to mark it as trackable.
+      Trackable values are values that:
+
+      - Can change over their component’s lifetime and
+      - Should cause Ember to rerender if and when they change
+
+      We can do this by marking the field with the `@tracked` decorator.
+
+      @module @glimmer/tracking
+      @public
+    */
+    /**
+      Marks a property as tracked. By default, values that are rendered in Ember app
+      templates are _static_, meaning that updates to them won't cause the
+      application to rerender. Marking a property as tracked means that when that
+      property changes, any templates that used that property, directly or
+      indirectly, will rerender. For instance, consider this component:
+
+      ```handlebars
+      <div>Count: {{this.count}}</div>
+      <div>Times Ten: {{this.timesTen}}</div>
+      <div>
+        <button {{on "click" this.plusOne}}>
+          Plus One
+        </button>
+      </div>
+      ```
+
+      ```javascript
+      import Component from '@glimmer/component';
+      import { tracked } from '@glimmer/tracking';
+      import { action } from '@ember/object';
+
+      export default class CounterComponent extends Component {
+        @tracked count = 0;
+
+        get timesTen() {
+          return this.count * 10;
+        }
+
+        @action
+        plusOne() {
+          this.count += 1;
+        }
+      }
+      ```
+
+      Both the `{{this.count}}` and the `{{this.timesTen}}` properties in the
+      template will update whenever the button is clicked. Any tracked properties
+      that are used in any way to calculate a value that is used in the template
+      will cause a rerender when updated - this includes through method calls and
+      other means:
+
+      ```javascript
+      import Component from '@glimmer/component';
+      import { tracked } from '@glimmer/tracking';
+
+      class Entry {
+        @tracked name;
+        @tracked phoneNumber;
+
+        constructor(name, phoneNumber) {
+          this.name = name;
+          this.phoneNumber = phoneNumber;
+        }
+      }
+
+      export default class PhoneBookComponent extends Component {
+        entries = [
+          new Entry('Pizza Palace', 5551234),
+          new Entry('1st Street Cleaners', 5554321),
+          new Entry('Plants R Us', 5552468),
+        ];
+
+        // Any usage of this property will update whenever any of the names in the
+        // entries arrays are updated
+        get names() {
+          return this.entries.map(e => e.name);
+        }
+
+        // Any usage of this property will update whenever any of the numbers in the
+        // entries arrays are updated
+        get numbers() {
+          return this.getFormattedNumbers();
+        }
+
+        getFormattedNumbers() {
+          return this.entries
+            .map(e => e.phoneNumber)
+            .map(number => {
+              let numberString = '' + number;
+
+              return numberString.slice(0, 3) + '-' + numberString.slice(3);
+            });
+        }
+      }
+      ```
+
+      It's important to note that setting tracked properties will always trigger an
+      update, even if the property is set to the same value as it was before.
+
+      ```js
+      let entry = new Entry('Pizza Palace', 5551234);
+      // if entry was used when rendering, this would cause a rerender, even though
+      // the name is being set to the same value as it was before
+      entry.name = entry.name;
+      ```
+
+      `tracked` can also be used with the classic Ember object model in a similar
+      manner to classic computed properties:
+
+      ```javascript
+      import EmberObject from '@ember/object';
+      import { tracked } from '@glimmer/tracking';
+
+      const Entry = EmberObject.extend({
+        name: tracked(),
+        phoneNumber: tracked()
+      });
+      ```
+
+      Often this is unnecessary, but to ensure robust auto-tracking behavior it is
+      advisable to mark tracked state appropriately wherever possible.
+      This form of `tracked` also accepts an optional configuration object
+      containing either an initial `value` or an `initializer` function (but not
+      both).
+
+      ```javascript
+      import EmberObject from '@ember/object';
+      import { tracked } from '@glimmer/tracking';
+
+      const Entry = EmberObject.extend({
+        name: tracked({ value: 'Zoey' }),
+        favoriteSongs: tracked({
+          initializer: () => ['Raspberry Beret', 'Time After Time']
+        })
+      });
+      ```
+
+      @method tracked
+      @static
+      @for @glimmer/tracking
+      @public
+    */
+    /**
+      The `@cached` decorator can be used on getters in order to cache the return
+      value of the getter. This is useful when a getter is expensive and used very
+      often. For instance, in this guest list class, we have the `sortedGuests`
+      getter that sorts the guests alphabetically:
+
+      ```js
+      import { tracked } from '@glimmer/tracking';
+
+      class GuestList {
+        @tracked guests = ['Zoey', 'Tomster'];
+
+        get sortedGuests() {
+          return this.guests.slice().sort()
+        }
+      }
+      ```
+
+      Every time `sortedGuests` is accessed, a new array will be created and sorted,
+      because JavaScript getters do not cache by default. When the guest list is
+      small, like the one in the example, this is not a problem. However, if the guest
+      list were to grow very large, it would mean that we would be doing a large
+      amount of work each time we accessed `sortedGetters`. With `@cached`, we can
+      cache the value instead:
+
+      ```js
+      import { tracked, cached } from '@glimmer/tracking';
+
+      class GuestList {
+        @tracked guests = ['Zoey', 'Tomster'];
+
+        @cached
+        get sortedGuests() {
+          return this.guests.slice().sort()
+        }
+      }
+      ```
+
+      Now the `sortedGuests` getter will be cached based on _autotracking_. It will
+      only rerun and create a new sorted array when the `guests` tracked property is
+      updated.
+
+      In general, you should avoid using `@cached` unless you have confirmed that the
+      getter you are decorating is computationally expensive. `@cached` adds a small
+      amount of overhead to the getter, making it more expensive. While this overhead
+      is small, if `@cached` is overused it can add up to a large impact overall in
+      your app. Many getters and tracked properties are only accessed once, rendered,
+      and then never rerendered, so adding `@cached` when it is unnecessary can
+      negatively impact performance.
+
+      @method cached
+      @static
+      @for @glimmer/tracking
+      @public
+     */
+}

package/external-types/ember-source/types/stable/@glimmer/tracking/primitives/cache.d.ts

@@ -0,0 +1,3 @@
+declare module '@glimmer/tracking/primitives/cache' {
+    export { createCache, getValue, isConst } from "@ember/-internals/metal";
+}

package/external-types/ember-source/types/stable/ember/barrel.d.ts

@@ -0,0 +1,370 @@
+declare module 'ember/barrel' {
+    /**
+    @module ember
+    */
+    import * as utils from "@ember/-internals/utils";
+    import { Registry as InternalRegistry, Container as InternalContainer } from "@ember/-internals/container";
+    import * as instrumentation from "@ember/instrumentation";
+    import * as metal from "@ember/-internals/metal";
+    import { isEnabled } from "@ember/canary-features";
+    import * as EmberDebug from "@ember/debug";
+    import Backburner from "backburner.js";
+    import EmberController, { inject as injectController, ControllerMixin as EmberControllerMixin } from "@ember/controller";
+    import EmberService from "@ember/service";
+    import EmberObject, { action, observer as emberObserver } from "@ember/object";
+    import { dependentKeyCompat } from "@ember/object/compat";
+    import EmberComputedProperty from "@ember/object/computed";
+    import { RSVP as _RSVP, Comparable as InternalComparable, ActionHandler as InternalActionHandler } from "@ember/-internals/runtime";
+    import { componentCapabilities, modifierCapabilities, setComponentManager, template, isSerializationFirstNode, type TemplatesRegistry } from "@ember/-internals/glimmer";
+    import * as views from "@ember/-internals/views";
+    import EmberContainerDebugAdapter from "@ember/debug/container-debug-adapter";
+    import EmberDataAdapter from "@ember/debug/data-adapter";
+    import { run as emberRun } from "@ember/runloop";
+    import EmberArray, { NativeArray as EmberNativeArray, isArray as emberIsArray, makeArray as emberMakeArray } from "@ember/array";
+    import EmberMutableArray from "@ember/array/mutable";
+    import EmberArrayProxy from "@ember/array/proxy";
+    import EmberApplication, { onLoad as applicationOnLoad, runLoadHooks as applicationRunLoadHooks } from "@ember/application";
+    import EmberApplicationInstance from "@ember/application/instance";
+    import EmberNamespace from "@ember/application/namespace";
+    import EmberComponent, { Input as EmberInput } from "@ember/component";
+    import EmberHelper from "@ember/component/helper";
+    import EmberEngine from "@ember/engine";
+    import EmberEngineInstance from "@ember/engine/instance";
+    import EmberEnumerable from "@ember/enumerable";
+    import EmberMutableEnumerable from "@ember/enumerable/mutable";
+    import EmberCoreObject from "@ember/object/core";
+    import EmberEvented from "@ember/object/evented";
+    import EmberMixin, { mixin as emberMixin } from "@ember/object/mixin";
+    import EmberObservable from "@ember/object/observable";
+    import EmberObjectProxy from "@ember/object/proxy";
+    import EmberPromiseProxyMixin from "@ember/object/promise-proxy-mixin";
+    import EmberHashLocation from "@ember/routing/hash-location";
+    import EmberHistoryLocation from "@ember/routing/history-location";
+    import EmberNoneLocation from "@ember/routing/none-location";
+    import EmberRoute from "@ember/routing/route";
+    import EmberRouter from "@ember/routing/router";
+    import { controllerFor as emberControllerFor, generateController as emberGenerateController, generateControllerFactory as emberGenerateControllerFactory, DSL as EmberRouterDSL } from "@ember/routing/-internals";
+    import { isNone as emberIsNone, isBlank as emberIsBlank, isEmpty as emberIsEmpty, isPresent as emberIsPresent, isEqual as emberIsEqual, typeOf as emberTypeOf, compare as emberCompare } from "@ember/utils";
+    import * as glimmerRuntime from "@glimmer/runtime";
+    import { helperCapabilities, setModifierManager, setComponentTemplate, getComponentTemplate, setHelperManager } from "@glimmer/manager";
+    import { associateDestroyableChild, registerDestructor, unregisterDestructor } from "@ember/destroyable";
+    import type { precompile, compile } from "ember-template-compiler";
+    import { _impl as EmberTestingImpl } from "@ember/test";
+    namespace Ember {
+        const isNamespace = true;
+        function toString(): string;
+        const Container: typeof InternalContainer;
+        type Container = InternalContainer;
+        const Registry: typeof InternalRegistry;
+        type Registry = InternalRegistry;
+        const _setComponentManager: typeof setComponentManager;
+        const _componentManagerCapabilities: typeof componentCapabilities;
+        const _modifierManagerCapabilities: typeof modifierCapabilities;
+        const meta: {
+            (obj: object): import("@ember/-internals/meta").Meta;
+            _counters?: import("@ember/-internals/meta").MetaCounters | undefined;
+        };
+        const _createCache: typeof metal.createCache;
+        const _cacheGetValue: typeof metal.getValue;
+        const _cacheIsConst: typeof metal.isConst;
+        const _descriptor: typeof metal.nativeDescDecorator;
+        const _getPath: typeof metal._getPath;
+        const _setClassicDecorator: typeof metal.setClassicDecorator;
+        const _tracked: typeof metal.tracked;
+        const beginPropertyChanges: typeof metal.beginPropertyChanges;
+        const changeProperties: typeof metal.changeProperties;
+        const endPropertyChanges: typeof metal.endPropertyChanges;
+        const hasListeners: typeof metal.hasListeners;
+        const libraries: metal.Libraries;
+        const _ContainerProxyMixin: EmberMixin;
+        const _ProxyMixin: EmberMixin;
+        const _RegistryProxyMixin: EmberMixin;
+        const ActionHandler: EmberMixin;
+        type ActionHandler = InternalActionHandler;
+        const Comparable: EmberMixin;
+        type Comparable = InternalComparable;
+        const ComponentLookup: Readonly<typeof EmberObject> & (new (owner?: import("@ember/owner").default | undefined) => EmberObject) & {
+            componentFor(name: string, owner: import("@ember/-internals/owner").InternalOwner): import("@ember/owner").FactoryManager<object> | undefined;
+            layoutFor(name: string, owner: import("@ember/-internals/owner").InternalOwner, options: import("@ember/owner").RegisterOptions): unknown;
+        };
+        const EventDispatcher: typeof views.EventDispatcher;
+        const _Cache: typeof utils.Cache;
+        const GUID_KEY: `__ember${number}`;
+        const canInvoke: typeof utils.canInvoke;
+        const generateGuid: typeof utils.generateGuid;
+        const guidFor: typeof utils.guidFor;
+        const uuid: typeof utils.uuid;
+        const wrap: typeof utils.wrap;
+        const getOwner: (object: object) => import("@ember/owner").default | undefined;
+        const onLoad: typeof applicationOnLoad;
+        const runLoadHooks: typeof applicationRunLoadHooks;
+        const setOwner: typeof import("@ember/owner").setOwner;
+        const Application: typeof EmberApplication;
+        type Application = EmberApplication;
+        const ApplicationInstance: typeof EmberApplicationInstance;
+        type ApplicationInstance = EmberApplicationInstance;
+        const Namespace: typeof EmberNamespace;
+        type Namespace = EmberNamespace;
+        const A: <T>(arr?: T[] | undefined) => EmberNativeArray<T>;
+        const Array: EmberMixin;
+        type Array<T> = EmberArray<T>;
+        const NativeArray: EmberMixin;
+        type NativeArray<T> = EmberNativeArray<T>;
+        const isArray: typeof emberIsArray;
+        const makeArray: typeof emberMakeArray;
+        const MutableArray: EmberMixin;
+        type MutableArray<T> = EmberMutableArray<T>;
+        const ArrayProxy: typeof EmberArrayProxy;
+        type ArrayProxy<T> = EmberArrayProxy<T>;
+        const FEATURES: {
+            isEnabled: typeof isEnabled;
+        };
+        const _Input: EmberInput;
+        const Component: typeof EmberComponent;
+        type Component<S = unknown> = EmberComponent<S>;
+        const Helper: typeof EmberHelper;
+        type Helper<S = unknown> = EmberHelper<S>;
+        const Controller: typeof EmberController;
+        type Controller<T = unknown> = EmberController<T>;
+        const ControllerMixin: EmberMixin;
+        type ControllerMixin<T> = EmberControllerMixin<T>;
+        const _captureRenderTree: typeof EmberDebug.captureRenderTree;
+        const assert: import("@ember/debug/lib/assert").AssertFunc;
+        const warn: import("@ember/debug/lib/warn").WarnFunc;
+        const debug: EmberDebug.DebugFunc;
+        const deprecate: typeof EmberDebug.deprecate;
+        const deprecateFunc: EmberDebug.DeprecateFuncFunc;
+        const runInDebug: EmberDebug.RunInDebugFunc;
+        const inspect: typeof EmberDebug.inspect;
+        const Debug: {
+            registerDeprecationHandler: (handler: import("@ember/debug/lib/handlers").HandlerCallback<EmberDebug.DeprecationOptions>) => void;
+            registerWarnHandler: import("@ember/debug/lib/warn").RegisterHandlerFunc;
+            isComputed: typeof metal.isComputed;
+        };
+        const ContainerDebugAdapter: typeof EmberContainerDebugAdapter;
+        type ContainerDebugAdapter = EmberContainerDebugAdapter;
+        const DataAdapter: typeof EmberDataAdapter;
+        type DataAdapter<T> = EmberDataAdapter<T>;
+        const _assertDestroyablesDestroyed: (() => void) | undefined;
+        const _associateDestroyableChild: typeof associateDestroyableChild;
+        const _enableDestroyableTracking: (() => void) | undefined;
+        const _isDestroying: typeof glimmerRuntime.isDestroying;
+        const _isDestroyed: typeof glimmerRuntime.isDestroyed;
+        const _registerDestructor: typeof registerDestructor;
+        const _unregisterDestructor: typeof unregisterDestructor;
+        const destroy: typeof glimmerRuntime.destroy;
+        const Engine: typeof EmberEngine;
+        type Engine = EmberEngine;
+        const EngineInstance: typeof EmberEngineInstance;
+        type EngineInstance = EmberEngineInstance;
+        const Enumerable: EmberMixin;
+        type Enumerable = EmberEnumerable;
+        const MutableEnumerable: EmberMixin;
+        type MutableEnumerable = EmberMutableEnumerable;
+        /** @private */
+        const instrument: typeof instrumentation.instrument;
+        /** @private */
+        const subscribe: typeof instrumentation.subscribe;
+        /** @private */
+        const Instrumentation: {
+            instrument: typeof instrumentation.instrument;
+            subscribe: typeof instrumentation.subscribe;
+            unsubscribe: typeof instrumentation.unsubscribe;
+            reset: typeof instrumentation.reset;
+        };
+        const Object: typeof EmberObject;
+        type Object = EmberObject;
+        const _action: typeof action;
+        const computed: typeof metal.computed;
+        const defineProperty: typeof metal.defineProperty;
+        const get: typeof metal.get;
+        const getProperties: typeof metal.getProperties;
+        const notifyPropertyChange: typeof metal.notifyPropertyChange;
+        const observer: typeof emberObserver;
+        const set: typeof metal.set;
+        const trySet: typeof metal.trySet;
+        const setProperties: typeof metal.setProperties;
+        const cacheFor: typeof metal.getCachedValueFor;
+        const _dependentKeyCompat: typeof dependentKeyCompat;
+        const ComputedProperty: typeof metal.ComputedProperty;
+        type ComputedProperty = EmberComputedProperty;
+        const expandProperties: typeof metal.expandProperties;
+        const CoreObject: typeof EmberCoreObject;
+        type CoreObject = EmberCoreObject;
+        const Evented: EmberMixin;
+        type Evented = EmberEvented;
+        const on: typeof metal.on;
+        const addListener: typeof metal.addListener;
+        const removeListener: typeof metal.removeListener;
+        const sendEvent: typeof metal.sendEvent;
+        const Mixin: typeof EmberMixin;
+        type Mixin = EmberMixin;
+        const mixin: typeof emberMixin;
+        const Observable: EmberMixin;
+        type Observable = EmberObservable;
+        const addObserver: typeof metal.addObserver;
+        const removeObserver: typeof metal.removeObserver;
+        const PromiseProxyMixin: EmberMixin;
+        type PromiseProxyMixin<T> = EmberPromiseProxyMixin<T>;
+        const ObjectProxy: typeof EmberObjectProxy;
+        type ObjectProxy = EmberObjectProxy;
+        const RouterDSL: typeof EmberRouterDSL;
+        type RouterDSL = EmberRouterDSL;
+        const controllerFor: typeof emberControllerFor;
+        const generateController: typeof emberGenerateController;
+        const generateControllerFactory: typeof emberGenerateControllerFactory;
+        const HashLocation: typeof EmberHashLocation;
+        type HashLocation = EmberHashLocation;
+        const HistoryLocation: typeof EmberHistoryLocation;
+        type HistoryLocation = EmberHistoryLocation;
+        const NoneLocation: typeof EmberNoneLocation;
+        type NoneLocation = EmberNoneLocation;
+        const Route: typeof EmberRoute;
+        type Route = EmberRoute;
+        const Router: typeof EmberRouter;
+        type Router = EmberRouter;
+        const run: typeof emberRun;
+        const Service: typeof EmberService;
+        type Service = EmberService;
+        const compare: typeof emberCompare;
+        const isBlank: typeof emberIsBlank;
+        const isEmpty: typeof emberIsEmpty;
+        const isEqual: typeof emberIsEqual;
+        const isNone: typeof emberIsNone;
+        const isPresent: typeof emberIsPresent;
+        const typeOf: typeof emberTypeOf;
+        /**
+          The semantic version
+      
+          @property VERSION
+          @type String
+          @public
+        */
+        const VERSION: string;
+        const ViewUtils: {
+            getChildViews: typeof views.getChildViews;
+            getElementView: typeof views.getElementView;
+            getRootViews: typeof views.getRootViews;
+            getViewBounds: typeof views.getViewBounds;
+            getViewBoundingClientRect: typeof views.getViewBoundingClientRect;
+            getViewClientRects: typeof views.getViewClientRects;
+            getViewElement: typeof views.getViewElement;
+            isSimpleClick: typeof views.isSimpleClick;
+            isSerializationFirstNode: typeof isSerializationFirstNode;
+        };
+        const _getComponentTemplate: typeof getComponentTemplate;
+        const _helperManagerCapabilities: typeof helperCapabilities;
+        const _setComponentTemplate: typeof setComponentTemplate;
+        const _setHelperManager: typeof setHelperManager;
+        const _setModifierManager: typeof setModifierManager;
+        const _templateOnlyComponent: typeof glimmerRuntime.templateOnlyComponent;
+        const _invokeHelper: typeof glimmerRuntime.invokeHelper;
+        const _hash: object;
+        const _array: object;
+        const _concat: object;
+        const _get: object;
+        const _on: {};
+        const _fn: object;
+        const _Backburner: typeof Backburner;
+        type _Backburner = Backburner;
+        /**
+          Namespace for injection helper methods.
+      
+          @class inject
+          @namespace Ember
+          @static
+          @public
+        */
+        function inject(): void;
+        namespace inject {
+            var controller: typeof injectController;
+            var service: typeof import("@ember/service").service;
+        }
+        const __loader: {
+            readonly require: any;
+            readonly define: any;
+            readonly registry: any;
+        };
+        const ENV: Readonly<object>;
+        let lookup: Record<string, unknown>;
+        /**
+          A function may be assigned to `Ember.onerror` to be called when Ember
+          internals encounter an error. This is useful for specialized error handling
+          and reporting code.
+      
+          ```javascript
+      
+          Ember.onerror = function(error) {
+            const payload = {
+              stack: error.stack,
+              otherInformation: 'whatever app state you want to provide'
+            };
+      
+            fetch('/report-error', {
+              method: 'POST',
+              body: JSON.stringify(payload)
+            });
+          };
+          ```
+      
+          Internally, `Ember.onerror` is used as Backburner's error handler.
+      
+          @event onerror
+          @for Ember
+          @param {Error} error the error object
+          @public
+        */
+        let onerror: ((error: Error) => unknown) | undefined;
+        let testing: boolean;
+        /**
+          Whether searching on the global for new Namespace instances is enabled.
+      
+          This is only exported here as to not break any addons.  Given the new
+          visit API, you will have issues if you treat this as a indicator of
+          booted.
+      
+          Internally this is only exposing a flag in Namespace.
+      
+          @property BOOTED
+          @for Ember
+          @type Boolean
+          @private
+        */
+        let BOOTED: boolean;
+        /**
+          Global hash of shared templates. This will automatically be populated
+          by the build tools so that you can store your Handlebars templates in
+          separate files that get loaded into JavaScript at buildtime.
+      
+          @property TEMPLATES
+          @for Ember
+          @type Object
+          @private
+        */
+        let TEMPLATES: TemplatesRegistry;
+        let HTMLBars: EmberHTMLBars;
+        let Handlebars: EmberHandlebars;
+        let Test: (NonNullable<typeof EmberTestingImpl>["Test"] & {
+            Adapter: NonNullable<typeof EmberTestingImpl>["Adapter"];
+            QUnitAdapter: NonNullable<typeof EmberTestingImpl>["QUnitAdapter"];
+        }) | undefined;
+        let setupForTesting: NonNullable<typeof EmberTestingImpl>["setupForTesting"] | undefined;
+    }
+    namespace Ember {
+        export import RSVP = _RSVP;
+    }
+    interface EmberHandlebars {
+        template: typeof template;
+        Utils: {};
+        compile?: typeof compile;
+        precompile?: typeof precompile;
+    }
+    interface EmberHTMLBars {
+        template: typeof template;
+        compile?: typeof compile;
+        precompile?: typeof precompile;
+    }
+    let EmberHandlebars: EmberHandlebars;
+    let EmberHTMLBars: EmberHTMLBars;
+    export default Ember;
+}