@discourse/types 0.0.1 → 0.0.2

package/external-types/ember-modifier/declarations/-private/class-based/modifier.d.ts

@@ -0,0 +1,66 @@
+declare module 'ember-modifier/-private/class-based/modifier' {
+import type Owner from '@ember/owner';
+import type { ElementFor, ArgsFor, DefaultSignature, PositionalArgs, NamedArgs } from '../signature';
+import type Opaque from '../opaque';
+export default interface ClassBasedModifier<S = DefaultSignature> extends Opaque<S> {
+}
+/**
+ * A base class for modifiers which need more capabilities than function-based
+ * modifiers. Useful if, for example:
+ *
+ * 1. You need to inject services and access them
+ * 2. You need fine-grained control of updates, either for performance or
+ *    convenience reasons, and don't want to teardown the state of your modifier
+ *    every time only to set it up again.
+ * 3. You need to store some local state within your modifier.
+ *
+ * The lifecycle hooks of class modifiers are tracked. When they run, they any
+ * values they access will be added to the modifier, and the modifier will
+ * update if any of those values change.
+ */
+export default class ClassBasedModifier<S = DefaultSignature> {
+    /**
+     *
+     * @param owner An instance of an Owner (for service injection etc.).
+     * @param args The positional and named arguments passed to the modifier.
+     */
+    constructor(owner: Owner, args: ArgsFor<S>);
+    /**
+     * Called when the modifier is installed and any time any tracked state used
+     * in the modifier changes.
+     *
+     * If you need to do first-time-only setup, create a class field representing
+     * the initialization state and check it when running the hook. That is also
+     * where and when you should use `registerDestructor` for any teardown you
+     * need to do. For example:
+     *
+     * ```js
+     * function disconnect(instance) {
+     *  instance.observer?.disconnect();
+     * }
+     *
+     * class IntersectionObserver extends Modifier {
+     *   observer;
+     *
+     *   constructor(owner, args) {
+     *     super(owner, args);
+     *     registerDestructor(this, disconnect);
+     *   }
+     *
+     *   modify(element, callback, options) {
+     *     disconnect(this);
+     *
+     *     this.observer = new IntersectionObserver(callback, options);
+     *     this.observer.observe(element);
+     *   }
+     * }
+     * ```
+     *
+     * @param element The element to which the modifier is applied.
+     * @param positional The positional arguments to the modifier.
+     * @param named The named arguments to the modifier.
+     */
+    modify(element: ElementFor<S>, positional: PositionalArgs<S>, named: NamedArgs<S>): void;
+}
+//# sourceMappingURL=modifier.d.ts.map
+}

package/external-types/ember-modifier/declarations/-private/function-based/modifier-manager.d.ts

@@ -0,0 +1,25 @@
+declare module 'ember-modifier/-private/function-based/modifier-manager' {
+import type { FunctionBasedModifierDefinition, Teardown } from './modifier';
+import type { ArgsFor, ElementFor } from '../signature';
+interface State<S> {
+    instance: FunctionBasedModifierDefinition<S>;
+}
+interface CreatedState<S> extends State<S> {
+    element: null;
+}
+interface InstalledState<S> extends State<S> {
+    element: ElementFor<S>;
+    teardown?: Teardown;
+}
+export default class FunctionBasedModifierManager<S> {
+    capabilities: unknown;
+    createModifier(instance: FunctionBasedModifierDefinition<S>): CreatedState<S>;
+    installModifier(createdState: CreatedState<S>, element: ElementFor<S>, args: ArgsFor<S>): void;
+    updateModifier(state: InstalledState<S>, args: ArgsFor<S>): void;
+    destroyModifier(state: InstalledState<S>): void;
+    getDebugName(state: InstalledState<S>): string;
+    getDebugInstance(state: InstalledState<S>): InstalledState<S>;
+}
+export {};
+//# sourceMappingURL=modifier-manager.d.ts.map
+}

package/external-types/ember-modifier/declarations/-private/function-based/modifier.d.ts

@@ -0,0 +1,71 @@
+declare module 'ember-modifier/-private/function-based/modifier' {
+import type { ElementFor, EmptyObject, NamedArgs, PositionalArgs } from '../signature';
+import type Modifier from '../class-based/modifier';
+export declare abstract class FunctionBasedModifierInstance<S> extends Modifier<S> {
+    protected abstract __concrete__: never;
+}
+export type FunctionBasedModifier<S> = abstract new () => FunctionBasedModifierInstance<S>;
+/**
+ * The (optional) return type for a modifier which needs to perform some kind of
+ * cleanup or teardown -- for example, removing an event listener from an
+ * element besides the one passed into the modifier.
+ */
+export type Teardown = () => unknown;
+/**
+ * An API for writing simple modifiers.
+ *
+ * This function runs the first time when the element the modifier was applied
+ * to is inserted into the DOM, and it *autotracks* while running. Any values
+ * that it accesses will be tracked, including any of its arguments that it
+ * accesses, and if any of them changes, the function will run again.
+ *
+ * **Note:** this will *not* automatically rerun because an argument changes. It
+ * will only rerun if it is *using* that argument (the same as with auto-tracked
+ * state in general).
+ *
+ * The modifier can also optionally return a *destructor*. The destructor
+ * function will be run just before the next update, and when the element is
+ * being removed entirely. It should generally clean up the changes that the
+ * modifier made in the first place.
+ *
+ * @param fn The function which defines the modifier.
+ */
+export default function modifier<E extends Element, P extends unknown[], N = EmptyObject>(fn: (element: E, positional: P, named: N) => void | Teardown): FunctionBasedModifier<{
+    Args: {
+        Positional: P;
+        Named: N;
+    };
+    Element: E;
+}>;
+/**
+ * An API for writing simple modifiers.
+ *
+ * This function runs the first time when the element the modifier was applied
+ * to is inserted into the DOM, and it *autotracks* while running. Any values
+ * that it accesses will be tracked, including any of its arguments that it
+ * accesses, and if any of them changes, the function will run again.
+ *
+ * **Note:** this will *not* automatically rerun because an argument changes. It
+ * will only rerun if it is *using* that argument (the same as with auto-tracked
+ * state in general).
+ *
+ * The modifier can also optionally return a *destructor*. The destructor
+ * function will be run just before the next update, and when the element is
+ * being removed entirely. It should generally clean up the changes that the
+ * modifier made in the first place.
+ *
+ * @param fn The function which defines the modifier.
+ */
+export default function modifier<S>(fn: (element: ElementFor<S>, positional: PositionalArgs<S>, named: NamedArgs<S>) => void | Teardown): FunctionBasedModifier<{
+    Element: ElementFor<S>;
+    Args: {
+        Named: NamedArgs<S>;
+        Positional: PositionalArgs<S>;
+    };
+}>;
+/**
+ * @internal
+ */
+export type FunctionBasedModifierDefinition<S> = (element: ElementFor<S>, positional: PositionalArgs<S>, named: NamedArgs<S>) => void | Teardown;
+//# sourceMappingURL=modifier.d.ts.map
+}

package/external-types/ember-modifier/declarations/-private/opaque.d.ts

@@ -0,0 +1,10 @@
+declare module 'ember-modifier/-private/opaque' {
+declare const Brand: unique symbol;
+declare class _Opaque<T> {
+    private readonly [Brand];
+}
+interface Opaque<T> extends _Opaque<T> {
+}
+export default Opaque;
+//# sourceMappingURL=opaque.d.ts.map
+}

package/external-types/ember-modifier/declarations/-private/signature.d.ts

@@ -0,0 +1,107 @@
+declare module 'ember-modifier/-private/signature' {
+/** @private */
+export type ElementFor<S> = 'Element' extends keyof S ? S['Element'] extends Element ? S['Element'] : Element : Element;
+type DefaultPositional = [];
+type GetOrElse<T, K, Fallback> = K extends keyof T ? T[K] : Fallback;
+/**
+ * A convenience type utility, primarily for working with args in the `modify`
+ * hook on class-based modifiers. Given a signature `S` it will return the
+ * correct positional args for that signature. For example:
+ *
+ * ```ts
+ * import Modifier, { NamedArgs } from 'ember-modifier';
+ *
+ * interface OnClickOutsideSig {
+ *   Args: {
+ *     Positional: [handler: () => void];
+ *   };
+ * }
+ *
+ * export default class Example extends Modifier<OnClickOutsideSig> {
+ *   element = null;
+ *
+ *   modify(el: Element, _: [handler]: PositionalArgs<OnClickOutsideSig>) {
+ *     if (!this.element) {
+ *       this.element = el;
+ *     }
+ *
+ *     this.clearHandler();
+ *     this.handler = handler;
+ *
+ *     document.addEventListener('click', this.onClickOutside);
+ *
+ *     // Normally this would be better done in `constructor` or similar.
+ *     unregisterDestructor(this, this.clearHandler);
+ *     registerDestructor(this, this.clearHandler);
+ *   }
+ *
+ *   onClickOutside = (event: MouseEvent) => {
+ *     // SAFETY: a "standard" safe cast for event.target here
+ *     if (!this.element.contains(event.target as Node)) {
+ *       this.handler();
+ *     }
+ *   }
+ *
+ *   clearHandler = () => {
+ *     document.removeEventListener('click', this.onClickOutside);
+ *   }
+ * }
+ * ```
+ *
+ * (This example does not need to be, and should not be, class-based, but is
+ * useful to illustrate how to use the type utility.)
+ */
+export type PositionalArgs<S> = 'Args' extends keyof S ? GetOrElse<S['Args'], 'Positional', DefaultPositional> : DefaultPositional;
+declare const Empty: unique symbol;
+export interface EmptyObject {
+    [Empty]?: true;
+}
+type DefaultNamed = EmptyObject;
+/**
+ * A convenience type utility, primarily for working with args in the `modify`
+ * hook on class-based modifiers. Given a signature `S` it will return the
+ * correct named args for that signature:
+ *
+ * ```ts
+ * import Modifier, { NamedArgs } from 'ember-modifier';
+ *
+ * interface PlaySig {
+ *   Element: HTMLElement;
+ *   Args: {
+ *     Named: {
+ *       when: string;
+ *     };
+ *   };
+ * }
+ *
+ * export default class Example extends Modifier<Sig> {
+ *   modify(el: HTMLMediaElement, _: [], { when: shouldPlay }: NamedArgs<PlaySig>) {
+ *     if (shouldPlay) {
+ *       el.play();
+ *     } else {
+ *       el.pause();
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * (This example does not need to be, and should not be, class-based, but is
+ * useful to illustrate the point.)
+ */
+export type NamedArgs<S> = 'Args' extends keyof S ? GetOrElse<S['Args'], 'Named', DefaultNamed> : DefaultNamed;
+/** @private */
+export interface DefaultSignature {
+    Element: Element;
+}
+/**
+ * A convenience type utility, primarily for working with args in the `modify`
+ * hook on class-based modifiers. Given a signature `S` it will return the
+ * correct positional args for that signature, to be used with
+ */
+export interface ArgsFor<S> {
+    named: NamedArgs<S>;
+    positional: PositionalArgs<S>;
+}
+export {};
+//# sourceMappingURL=signature.d.ts.map
+}

package/external-types/ember-modifier/declarations/index.d.ts

@@ -0,0 +1,7 @@
+declare module 'ember-modifier' {
+export { default } from './-private/class-based/modifier.ts';
+export { default as modifier } from './-private/function-based/modifier.ts';
+export type { FunctionBasedModifier } from './-private/function-based/modifier.ts';
+export type { ArgsFor, NamedArgs, PositionalArgs, } from './-private/signature.ts';
+//# sourceMappingURL=index.d.ts.map
+}

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

@@ -0,0 +1,107 @@
+{
+  "name": "ember-modifier",
+  "version": "4.2.2",
+  "description": "A library for writing Ember modifiers",
+  "keywords": [
+    "ember-addon"
+  ],
+  "repository": "https://github.com/ember-modifier/ember-modifier",
+  "license": "MIT",
+  "author": "",
+  "exports": {
+    ".": {
+      "types": "./declarations/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./declarations/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./addon-main.js": "./addon-main.cjs"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "declarations/*"
+      ],
+      "./-private/signature": [
+        "./dist/-private/signature.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "addon-main.cjs",
+    "blueprints",
+    "declarations",
+    "dist"
+  ],
+  "dependencies": {
+    "@embroider/addon-shim": "^1.8.7",
+    "decorator-transforms": "^2.0.0",
+    "ember-cli-normalize-entity-name": "^1.0.0",
+    "ember-cli-string-utils": "^1.1.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.25.2",
+    "@babel/plugin-transform-typescript": "^7.25.2",
+    "@babel/runtime": "^7.25.6",
+    "@embroider/addon-dev": "^5.0.0",
+    "@glimmer/component": "^1.1.2",
+    "@glint/core": "^1.4.0",
+    "@glint/environment-ember-loose": "^1.4.0",
+    "@glint/environment-ember-template-imports": "^1.4.0",
+    "@glint/template": "^1.4.0",
+    "@rollup/plugin-babel": "^6.0.4",
+    "@tsconfig/ember": "^3.0.2",
+    "@types/rsvp": "^4.0.9",
+    "@typescript-eslint/eslint-plugin": "^7.15.0",
+    "@typescript-eslint/parser": "^7.16.0",
+    "babel-plugin-ember-template-compilation": "^2.2.1",
+    "concurrently": "^9.0.1",
+    "ember-source": "~4.11.0",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-ember": "^12.2.0",
+    "eslint-plugin-import": "^2.30.0",
+    "eslint-plugin-n": "^17.10.3",
+    "eslint-plugin-prettier": "^5.2.1",
+    "expect-type": "^0.20.0",
+    "prettier": "^3.3.3",
+    "prettier-plugin-ember-template-tag": "^2.0.2",
+    "rollup": "^4.21.2",
+    "rollup-plugin-copy": "^3.5.0",
+    "typescript": "^5.5.4",
+    "webpack": "^5.94.0"
+  },
+  "volta": {
+    "extends": "../package.json"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "ember": {
+    "edition": "octane"
+  },
+  "ember-addon": {
+    "version": 2,
+    "type": "addon",
+    "main": "addon-main.cjs",
+    "versionCompatibility": {
+      "ember": "3.24 || 3.28 || >=4.0"
+    }
+  },
+  "scripts": {
+    "build": "concurrently 'pnpm:build:*'",
+    "build:js": "rollup --config",
+    "build:types": "glint --declaration",
+    "lint": "concurrently 'pnpm:lint:*(!fix)' --names 'lint:'",
+    "lint:fix": "concurrently 'pnpm:lint:*:fix' --names 'fix:'",
+    "lint:js": "eslint . --cache",
+    "lint:js:fix": "eslint . --fix",
+    "lint:types": "glint",
+    "start": "concurrently 'pnpm:start:*'",
+    "start:js": "rollup --config --watch --no-watch.clearScreen",
+    "start:types": "glint --declaration --watch",
+    "test": "echo 'A v2 addon does not have tests, run tests in test-app'"
+  }
+}

package/external-types/ember-qunit/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2017
+
+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.

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

@@ -0,0 +1,108 @@
+{
+  "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"
+  ],
+  "typesVersions": {
+    "*": {
+      "*": [
+        "types/*"
+      ]
+    }
+  },
+  "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"
+  }
+}