From 595cf86f921461918bffc727534c2721c14e7a15 Mon Sep 17 00:00:00 2001 From: Andrew Seier Date: Thu, 20 Nov 2025 20:31:55 -0800 Subject: [PATCH] =?UTF-8?q?Adds=20experimental=20=E2=80=9Cdecorators?= =?UTF-8?q?=E2=80=9D=20interface.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The TC39 proposals for JavaScript decorators and decorator metadata have made their way to stage 3. The next step is for browsers to begin implementing. It is not an “if” anymore, it is a “when”. This means that it’s time for us to explore what ergonomic improvements might be unlocked by enabling interoperation with these new interfaces. Some important notes: - We could ship this now (only integrator code requires new syntax). - The new interface _should_ be more idiomatic. - We should be able to delete some invented concepts entirely. Closes #346. --- .babelrc.json | 5 + CLAUDE.md | 3 +- DECORATORS.md | 788 ++++++++ eslint.config.js | 20 +- package-lock.json | 1053 +++++++++- package.json | 6 + test-next/index.html | 18 + test-next/index.js | 23 + test-next/test-analysis-errors.html | 18 + test-next/test-analysis-errors.js | 1031 ++++++++++ test-next/test-analysis-errors.src.js | 661 +++++++ test-next/test-attribute-changed-errors.html | 18 + test-next/test-attribute-changed-errors.js | 71 + .../test-attribute-changed-errors.src.js | 57 + test-next/test-basic-properties.html | 18 + test-next/test-basic-properties.js | 703 +++++++ test-next/test-basic-properties.src.js | 543 ++++++ test-next/test-computed-properties.html | 18 + test-next/test-computed-properties.js | 382 ++++ test-next/test-computed-properties.src.js | 315 +++ test-next/test-default-properties.html | 18 + test-next/test-default-properties.js | 289 +++ test-next/test-default-properties.src.js | 207 ++ test-next/test-element-upgrade.html | 18 + test-next/test-element-upgrade.js | 114 ++ test-next/test-element-upgrade.src.js | 161 ++ test-next/test-inheritance.html | 18 + test-next/test-inheritance.js | 679 +++++++ test-next/test-inheritance.src.js | 494 +++++ test-next/test-initial-properties.html | 18 + test-next/test-initial-properties.js | 222 +++ test-next/test-initial-properties.src.js | 167 ++ test-next/test-initialization-errors.html | 18 + test-next/test-initialization-errors.js | 181 ++ test-next/test-initialization-errors.src.js | 137 ++ test-next/test-internal-properties.html | 18 + test-next/test-internal-properties.js | 318 ++++ test-next/test-internal-properties.src.js | 294 +++ test-next/test-listeners.html | 18 + test-next/test-listeners.js | 542 ++++++ test-next/test-listeners.src.js | 463 +++++ test-next/test-observed-properties.html | 18 + test-next/test-observed-properties.js | 315 +++ test-next/test-observed-properties.src.js | 230 +++ test-next/test-parser.html | 18 + test-next/test-parser.js | 1686 +++++++++++++++++ test-next/test-property-deletion.html | 18 + test-next/test-property-deletion.js | 125 ++ test-next/test-property-deletion.src.js | 89 + test-next/test-read-only-properties.html | 18 + test-next/test-read-only-properties.js | 133 ++ test-next/test-read-only-properties.src.js | 104 + test-next/test-reflected-properties.html | 18 + test-next/test-reflected-properties.js | 122 ++ test-next/test-reflected-properties.src.js | 93 + test-next/test-render-root.html | 18 + test-next/test-render-root.js | 38 + test-next/test-render-root.src.js | 39 + test-next/test-render.html | 18 + test-next/test-render.js | 63 + test-next/test-render.src.js | 49 + test-next/test-scratch.html | 18 + test-next/test-scratch.js | 287 +++ test-next/test-scratch.src.js | 286 +++ test-next/test-styles.css | 6 + test-next/test-styles.html | 18 + test-next/test-styles.js | 84 + test-next/test-styles.src.js | 79 + test-next/test-template-engine.html | 20 + test-next/test-template-engine.js | 1149 +++++++++++ test/index.js | 7 +- transpile-decorators.js | 26 + tsconfig.json | 1 + types/x-element-next.d.ts | 261 +++ types/x-element-next.d.ts.map | 1 + x-element-next.js | 1027 ++++++++++ 76 files changed, 16567 insertions(+), 60 deletions(-) create mode 100644 .babelrc.json create mode 100644 DECORATORS.md create mode 100644 test-next/index.html create mode 100644 test-next/index.js create mode 100644 test-next/test-analysis-errors.html create mode 100644 test-next/test-analysis-errors.js create mode 100644 test-next/test-analysis-errors.src.js create mode 100644 test-next/test-attribute-changed-errors.html create mode 100644 test-next/test-attribute-changed-errors.js create mode 100644 test-next/test-attribute-changed-errors.src.js create mode 100644 test-next/test-basic-properties.html create mode 100644 test-next/test-basic-properties.js create mode 100644 test-next/test-basic-properties.src.js create mode 100644 test-next/test-computed-properties.html create mode 100644 test-next/test-computed-properties.js create mode 100644 test-next/test-computed-properties.src.js create mode 100644 test-next/test-default-properties.html create mode 100644 test-next/test-default-properties.js create mode 100644 test-next/test-default-properties.src.js create mode 100644 test-next/test-element-upgrade.html create mode 100644 test-next/test-element-upgrade.js create mode 100644 test-next/test-element-upgrade.src.js create mode 100644 test-next/test-inheritance.html create mode 100644 test-next/test-inheritance.js create mode 100644 test-next/test-inheritance.src.js create mode 100644 test-next/test-initial-properties.html create mode 100644 test-next/test-initial-properties.js create mode 100644 test-next/test-initial-properties.src.js create mode 100644 test-next/test-initialization-errors.html create mode 100644 test-next/test-initialization-errors.js create mode 100644 test-next/test-initialization-errors.src.js create mode 100644 test-next/test-internal-properties.html create mode 100644 test-next/test-internal-properties.js create mode 100644 test-next/test-internal-properties.src.js create mode 100644 test-next/test-listeners.html create mode 100644 test-next/test-listeners.js create mode 100644 test-next/test-listeners.src.js create mode 100644 test-next/test-observed-properties.html create mode 100644 test-next/test-observed-properties.js create mode 100644 test-next/test-observed-properties.src.js create mode 100644 test-next/test-parser.html create mode 100644 test-next/test-parser.js create mode 100644 test-next/test-property-deletion.html create mode 100644 test-next/test-property-deletion.js create mode 100644 test-next/test-property-deletion.src.js create mode 100644 test-next/test-read-only-properties.html create mode 100644 test-next/test-read-only-properties.js create mode 100644 test-next/test-read-only-properties.src.js create mode 100644 test-next/test-reflected-properties.html create mode 100644 test-next/test-reflected-properties.js create mode 100644 test-next/test-reflected-properties.src.js create mode 100644 test-next/test-render-root.html create mode 100644 test-next/test-render-root.js create mode 100644 test-next/test-render-root.src.js create mode 100644 test-next/test-render.html create mode 100644 test-next/test-render.js create mode 100644 test-next/test-render.src.js create mode 100644 test-next/test-scratch.html create mode 100644 test-next/test-scratch.js create mode 100644 test-next/test-scratch.src.js create mode 100644 test-next/test-styles.css create mode 100644 test-next/test-styles.html create mode 100644 test-next/test-styles.js create mode 100644 test-next/test-styles.src.js create mode 100644 test-next/test-template-engine.html create mode 100644 test-next/test-template-engine.js create mode 100644 transpile-decorators.js create mode 100644 types/x-element-next.d.ts create mode 100644 types/x-element-next.d.ts.map create mode 100644 x-element-next.js diff --git a/.babelrc.json b/.babelrc.json new file mode 100644 index 0000000..d6108f0 --- /dev/null +++ b/.babelrc.json @@ -0,0 +1,5 @@ +{ + "plugins": [ + ["@babel/plugin-proposal-decorators", { "version": "2023-05" }] + ] +} diff --git a/CLAUDE.md b/CLAUDE.md index 6a38f40..54d359d 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -145,4 +145,5 @@ files should be valid in the latest versions of Chrome, Firefox, and Safari. ## Miscellaneous Development Tips - Use the `--suffix` argument to save things like `--suffix=before` and `--suffix=after` for easier A/B testing. Don't forget to clean up these files after you are finished with all your tasks. -``` \ No newline at end of file +``` +- You can use the `--test-name="pattern"` feature from x-test to target specific tests by the text in the `it()`. \ No newline at end of file diff --git a/DECORATORS.md b/DECORATORS.md new file mode 100644 index 0000000..5a43207 --- /dev/null +++ b/DECORATORS.md @@ -0,0 +1,788 @@ +# Decorator-Based XElement Architecture + +## Overview + +This document describes the decorator-based API for `x-element` using TC39 +Stage 3+ decorators. The implementation is **complete and shipping** - users +can adopt it today with TypeScript 5.0+ or Babel transpilation, and the same +code will work natively when decorators reach Stage 4. + +```javascript +import { XElement, property, listener, html } from '@netflix/x-element'; + +class HelloWorldElement extends XElement { + @property({ type: String, default: 'World' }) + accessor name; + + @property({ type: Number, initial: 0 }) + accessor #count; + + @listener('click') + static #onClick(host) { + host.#count++; + } + + static template(host) { + return html``; + } +} + +customElements.define('hello-world', HelloWorldElement); +``` + +## Key Benefits + +✅ **Idiomatic JavaScript** - Leverages native language features instead of framework-specific patterns +✅ **True privacy** - Private accessors with `#` syntax, native JavaScript encapsulation +✅ **Better IntelliSense** - Decorators analyzed by IDEs, properties visible on prototype +✅ **No invented proxies** - Removes `this.properties` proxy and `this.internal` proxy concepts entirely +✅ **Simpler mental model** - Properties on prototype, callbacks stay static (like current API) +✅ **Simpler configuration** - All config options are simple, single words (removed `readOnly`) +✅ **No breaking changes** - Classic API supported through 2.x +✅ **Future-proof** - Ready for Stage 4 decorators + +## Key Concepts + +- **Constructor** - The class itself (e.g., `MyElement`), where static methods live +- **Prototype** - Where instance members are defined (`MyElement.prototype`) +- **Host** - The actual instance at runtime, passed to callbacks as first parameter +- **Shadow Root** - Shadow DOM render target (bi-directional with host) + +## Core Design Decisions + +1. Properties use auto-accessor syntax: `@property() accessor foo;` +2. Properties live on prototype for IntelliSense and type checking +3. Private properties use native `#` syntax: `@property() accessor #internal;` +4. Initial values via config (`initial`), not accessor initializers +5. No `readOnly` config - use identity transform: `compute: (v) => v` +6. Callbacks remain static method references (like classic API) +7. Arrow function wrappers to avoid TDZ: `(a, b) => MyElement.#method(a, b)` +8. Private static methods by convention (clean public API) +9. Input arrays use strings: `input: ['firstName', 'lastName']` +10. Listener signature: `@listener(type, options?)` +11. Template signature: `static template(host)` with imported `html` +12. Two-file structure: `x-element-next.js` (modern) + `x-element.js` (classic + re-exports) +13. No API mixing - use all-classic or all-modern in inheritance chain +14. Ships today via TypeScript / Babel, native when decorators reach Stage 4 + +## Shipping Before Stage 4 + +**Key insight:** The decorator API infrastructure can be shipped TODAY, even +before decorators reach Stage 4. + +### Why This Works + +The modern `XElement` class and decorator functions (`property()`, `listener()`) +are **just regular JavaScript**: + +```javascript +// x-element.js - Valid JavaScript today! ✅ +const decoratorProperties = new WeakMap(); + +export function property(config) { + return function(target, context) { // Just a function returning a function + decoratorProperties.set(target, config); + return { /* accessor descriptor */ }; + }; +} + +export class XElement extends HTMLElement { + constructor() { + super(); + // Read from WeakMaps - regular JavaScript code + const props = decoratorProperties.get(this.constructor.prototype); + // ... analyze and initialize + } +} +``` + +**Only USER CODE requires decorator support:** + +```javascript +// user-code.js - Requires decorator transpilation ❌ +import { XElement, property } from './x-element.js'; + +class MyElement extends XElement { + @property({ type: String }) // ← Decorator syntax (needs transpilation) + accessor foo; // ← Auto-accessor (needs transpilation) +} +``` + +### Practical Impact + +✅ **Ship immediately** - No need to wait for Stage 4 +✅ **Users adopt now** - With TypeScript 5.0+ or Babel transpilation +✅ **Gather feedback** - Real-world usage informs the API +✅ **Native support ready** - When Stage 4 ships, existing code _just works_ +✅ **No breaking changes** - Same code works with transpilation AND natively + +## Version Isolation + +**Design principle:** We trust developers to use a single x-element version +correctly throughout their application and avoid mixing different versions in +the same inheritance chain. + +### No Enforcement + +Version isolation is **not enforced** by x-element. Detecting and preventing +version mixing across an inheritance chain would require: + +1. Injecting version markers into prototypes +2. Walking the prototype chain during element construction +3. Comparing version identifiers at runtime +4. Handling edge cases like bundler deduplication, npm peer dependencies, + and monorepo scenarios + +This complexity was deemed **not worth the effort** given: + +- Module resolution naturally prevents most version mixing scenarios +- Expert developers understand dependency management +- Any issues that do arise surface as standard JS errors that can be debugged +- The performance cost of runtime checks is undesirable + +### Best Practices + +**Avoid version mixing:** +```javascript +// ✅ GOOD - Single version throughout +import { XElement, property } from 'x-element.js'; + +class Base extends XElement { + @property({ type: String }) + accessor name; +} + +class Derived extends Base { + @property({ type: Number }) + accessor age; +} +``` + +```javascript +// ❌ BAD - Mixing versions (not enforced, but will cause issues) +import { XElement as XElement1 } from 'x-element@1.0.0'; +import { XElement as XElement2 } from 'x-element@2.0.0'; + +class Base extends XElement1 { /* ... */ } +class Derived extends Base { /* ... */ } // Mixed versions in chain +``` + +### API Style Consistency + +Similarly, mixing classic and modern APIs in the same inheritance chain is +**not recommended** but **not enforced**: + +```javascript +// ❌ NOT RECOMMENDED - Mixing API styles +import XElement from 'x-element.js'; // Classic +import { property } from 'x-element.js'; // Modern + +class Base extends XElement { + static get properties() { + return { name: { type: String } }; // Classic API + } +} + +class Derived extends Base { + @property({ type: Number }) // Modern API + accessor age; +} +``` + +Each API style has its own internal metadata system. Mixing them may cause +confusing failures like properties not being defined or observers not running. +We trust developers to maintain consistency within an inheritance chain. + +## Template Signature Change (Proposed) + +**Proposed Change:** Update the template signature to import `html` instead of +receiving it as a parameter. The current `main` branch still passes `html` as +the first argument to `template(html)`, but the decorator-based API will use +imported `html` and a simplified `template(host)` signature. + +### New Signature (Modern) + +```javascript +import { XElement, property, html } from './x-element.js'; + +class MyElement extends XElement { + @property({ type: String }) + accessor name; + + static template(host) { + return html`

Hello ${host.name}!

`; + } +} +``` + +This direct approach: +- Import `html` from x-element +- Framework passes only `host` to `template()` +- Returns template result immediately (no currying) +- Direct property access via `host.name` +- Consistent with observers and listeners + +### Why `template(host)` with Imported `html`? + +Since x-element will restrict to its own template engine, we can import `html` +directly and simplify the template signature to just `template(host)`. + +**Alternative considered: `template(host, html)`** +- Would thread `html` as parameter +- **Rejected:** Since we're restricting to x-element's template engine, no need + to pass `html` as parameter +- **Rejected:** Importing `html` is cleaner and more consistent with other + decorator libraries + +**Why `template(host)` with imported `html` wins:** +- ✅ **Simplest signature** - Just one parameter +- ✅ **No threading** - Import `html` once, use anywhere +- ✅ **Consistency** - Matches patterns from other decorator libraries +- ✅ **Clean imports** - `import { XElement, property, listener, html }` + +**Caching:** For expensive setup, use static class fields instead of the curried pattern: +```javascript +static #dateFormatter = new Intl.DateTimeFormat('en-US'); +static template(host) { + return html`
${this.#dateFormatter.format(host.date)}
`; +} +``` + +## Naming Convention: Private Callbacks + +**Convention:** All compute, observe, and listener callbacks should be +**private static methods** using `#` syntax. This keeps the public API surface +clean—only properties should be public. + +- **Compute methods:** `static #computeFoo()` +- **Observers:** `static #observeFoo()` +- **Listeners:** `static #onClick()` + +The public API surface should consist **only of properties**. Callbacks are +implementation details. + +## Read-Only Properties Pattern + +To create a public read-only property with private write access, use a private property with a public computed property that applies an identity transform: + +```javascript +class MyElement extends XElement { + // Private writable property + @property({ type: String }) + accessor #value; + + // Public read-only via identity transform + @property({ + type: String, + input: ['#value'], + compute: (value) => value, // Pass through unchanged + }) + accessor value; + + @listener('click') + static #onClick(host, event) { + host.#value = 'new'; // ✅ Write to private + console.log(host.value); // ✅ Read from public computed + } +} +``` + +**How it works:** +- Private property (`#value`) is both readable and writable internally +- Public property (`value`) is computed from private property +- Identity transform `(value) => value` simply passes the value through +- Public property automatically updates when private property changes +- Attempting to set public property throws (computed properties are read-only) +- Read from either `host.#value` or `host.value` - choose based on context + +**Benefits:** +- ✅ Uses existing computed property system - no special concepts +- ✅ Explicit and clear - obvious it's a computed value +- ✅ Full property system integration (observers, dependencies work) +- ✅ Simple - just two regular property declarations + +## Method References: Arrow Function Wrappers + +To reference private static methods, use arrow function wrappers to avoid +Temporal Dead Zone (TDZ) errors: + +```javascript +class MyElement extends XElement { + @property({ + input: ['first', 'last'], + compute: (first, last) => MyElement.#computeFull(first, last), + }) + accessor full; + + @property({ + type: String, + observe: (host, value) => MyElement.#observeValue(host, value), + }) + accessor value; + + // Private static methods (implementation details, not public API) + static #computeFull(first, last) { + return `${first} ${last}`; + } + + static #observeValue(host, value) { + console.log('changed', value); + } +} +``` + +This gives us: +- ✅ Type-safe references (no strings!) +- ✅ IntelliSense support +- ✅ Refactor-safe +- ✅ No resolver functions needed +- ✅ Private static methods: `MyElement.#privateMethod` + +### Temporal Dead Zone (TDZ) Workaround + +**Note:** A potential ergonomic fix for this issue is being discussed at +[tc39/proposal-decorators#567](https://github.com/tc39/proposal-decorators/issues/567). + +**Important:** Directly referencing the class name in decorators **will cause +TDZ errors** because decorators run during class construction, before the class +name binding is fully initialized. + +**The solution: Wrap callbacks in arrow functions** to defer evaluation: + +```javascript +class MyElement extends XElement { + @property({ type: String }) + accessor first; + + @property({ type: String }) + accessor last; + + // ❌ WILL cause TDZ error (class reference evaluated immediately during + // decoration) + @property({ + input: ['first', 'last'], + compute: MyElement.#computeFull, // ReferenceError: Cannot access + // 'MyElement' before initialization + }) + accessor full; + + // ✅ Works - arrow function defers class reference until compute is called + @property({ + input: ['first', 'last'], + compute: (first, last) => MyElement.#computeFull(first, last), + }) + accessor full; + + static #computeFull(first, last) { + return `${first} ${last}`; + } +} +``` + +**Why this works:** +- Arrow function **body** is not evaluated until the function is called +- By the time x-element calls the compute function, class construction is + complete +- The class name binding is fully initialized + +**When to use this pattern:** +- ✅ Always safe to use for `compute` and `observe` callbacks +- ✅ Prevents TDZ errors across all environments +- ✅ Allows parameter flexibility - pass only what the method needs + +### Inline Arrow Functions for Simple Callbacks + +**For trivial compute or observe logic, use inline arrow functions:** + +```javascript +class MyElement extends XElement { + @property({ type: String }) + accessor firstName; + + @property({ type: String }) + accessor lastName; + + // Inline arrow function for simple compute + @property({ + input: ['firstName', 'lastName'], + compute: (first, last) => `${first} ${last}`, // ✅ Inline! + }) + accessor fullName; + + // Inline arrow function for simple observe + @property({ + type: Number, + observe: (host, value) => console.log('count:', value), // ✅ Inline! + }) + accessor count; + + // Inline for simple derived value + @property({ + input: ['count'], + compute: (count) => count * 2, // ✅ Inline! + }) + accessor doubled; +} +``` + +**When to use inline vs static methods:** + +**Use inline arrow functions when:** +- ✅ Logic is trivial (one line) +- ✅ No reuse needed +- ✅ Compute is a simple expression +- ✅ Observer just logs or sets simple value + +**Use private static methods when:** +- ✅ Logic is non-trivial (multiple lines) +- ✅ Method might be reused +- ✅ Needs testing separately +- ✅ Complex business logic + +**Example mixing both:** + +```javascript +class MyElement extends XElement { + @property({ + input: ['firstName', 'lastName'], + compute: (first, last) => `${first} ${last}`, // Simple - inline + }) + accessor fullName; + + @property({ + type: String, + // Complex - static method + observe: (host, value) => MyElement.#observeName(host, value), + }) + accessor name; + + static #observeName(host, value) { + // Complex logic with multiple statements + host.#updateCache(value); + host.#notifyListeners(value); + host.#logAnalytics('name_changed', { value }); + } +} +``` + +## Private Fields in Static Methods + +**Key insight:** Static methods can access private instance fields when passed +an instance as a parameter, because private fields are scoped to the class +lexical scope: + +```javascript +class MyElement extends XElement { + @property({ type: String }) + accessor #token; + + @listener('click') + static #onClick(host, event) { + host.#token = 'updated'; // ✅ Static method accesses private field via host + } +} +``` + +JavaScript enforces type safety - passing the wrong instance type throws a +TypeError. + +## DevTools Debugging: Private Field Introspection + +**Critical insight:** Chrome DevTools intentionally allows accessing and +modifying private fields in the console, making the private accessor pattern +practical for real development. + +```javascript +class MyElement extends XElement { + @property({ type: String }) + accessor #token; + + @property({ type: Number, initial: 0 }) + accessor #count; + + @property({ + type: String, + input: ['#token'], + compute: (token) => `public-${token}`, + }) + accessor publicValue; +} +``` + +**In the DevTools console:** +```javascript +// Select element in Elements panel, then in Console: +$0.#token // ✅ Read private field +$0.#token = 'debug-value' // ✅ Write private field +$0.#count // ✅ Inspect private state +$0.#count = 999 // ✅ Modify for testing +``` + +**Why this matters:** + +Without DevTools introspection, private accessors would create a debugging +nightmare - you couldn't inspect or modify internal state during development. +Chrome's intentional design choice to allow console access to private fields +makes this pattern practical: + +- ✅ True encapsulation in production code (private is enforced) +- ✅ Full debugging capability in DevTools (can inspect/modify private state) +- ✅ No special "debug mode" or framework code needed +- ✅ Test edge cases by manipulating private state during development +- ✅ Natural debugging workflow - select element, inspect state, modify values + +**This design wouldn't be viable without DevTools support.** The ability to +introspect private fields is what enables using native JavaScript privacy +features while maintaining an excellent developer experience. + +## Initial Values via Config + +All initial values must be specified in the `@property()` config, not as +accessor initializers. + +```javascript +class MyElement extends XElement { + // Scalar initial values + @property({ type: Number, initial: 0 }) + accessor count; + + @property({ type: String, initial: 'default' }) + accessor name; + + @property({ type: Boolean, initial: false }) + accessor active; + + // Arrays/Objects - MUST use function (to avoid shared references) + @property({ type: Array, initial: () => [] }) + accessor items; + + @property({ type: Object, initial: () => ({ foo: 'bar' }) }) + accessor data; + + // ❌ INVALID - accessor initializers throw error + @property({ type: Number }) + accessor bad = 0; // ❌ Throws: use initial config instead +} +``` + +**Why functions for non-scalars?** +- Scalars (Number, String, Boolean) are copied by value - safe to share +- Arrays/Objects are referenced - would be shared across all instances! +- Functions are called per-instance to create new values + +**Validation:** The decorator's `init()` function throws if any initializer is +provided: +```javascript +init(initialValue) { + if (initialValue !== undefined) { + throw new Error( + `Property "${context.name}" should not have an initializer. ` + + `Use initial config option instead: @property({ initial: ... })` + ); + } + return undefined; +} +``` + +**Benefits:** +- ✅ All configuration in one place +- ✅ Consistent with current x-element behavior +- ✅ TypeScript types properly express `initial?: T | (() => T)` +- ✅ Clear distinction between `initial` and `default` + +**`initial` vs `default`:** +- `initial` - Applied once during element initialization (if value is + nullish) +- `default` - Fallback value when property is set to `undefined` at runtime +```javascript +@property({ type: String, initial: 'initial', default: 'fallback' }) +accessor name; +``` + +## Input Arrays: Why Not Callbacks? + +**Design decision:** Use string arrays (`input: ['firstName', 'lastName']`) +rather than callbacks (`input: (host) => [host.firstName, host.lastName]`). + +A callback approach might provide better IntelliSense (live references to +properties), but was rejected for several reasons: + +**1. Callback interface feels wrong for declarative config:** +```javascript +// ❌ Callback feels imperative, not declarative +@property({ + input: (host) => [host.firstName, host.lastName], + compute: (first, last) => `${first} ${last}`, +}) +accessor fullName; + +// ✅ String array is clearly declarative +@property({ + input: ['firstName', 'lastName'], + compute: (first, last) => `${first} ${last}`, +}) +accessor fullName; +``` + +**2. Dangerous surface area during analysis:** + +The callback provides tempting-but-dangerous access to `host` during class +definition: + +```javascript +// ❌ What if developers do this? +@property({ + input: (host) => { + host.someMethod(); // Called during analysis? 😱 + console.log(host.otherProp); // Side effects during analysis? 😱 + return [host.firstName]; + }, + compute: (first) => `${first}`, +}) +accessor fullName; +``` + +This creates confusion about when the callback executes and encourages misuse. + +**3. Forces analysis timing to first construction:** + +Callback needs a `host` instance, forcing analysis to defer until first +construction (when an instance exists). We may do this anyway, but this design +would force our hand and eliminate analysis-at-definition as an option. + +**4. Requires overly clever initializer tricks:** + +To make IntelliSense work, we'd need to: +- Store a special symbol as the accessor initializer +- Detect this symbol during decorator execution +- This would force us to never accept user initializers, reducing flexibility + +```javascript +// Theoretical implementation would require: +@property({ + input: (host) => [host.firstName], + compute: (first) => first, +}) +accessor fullName = SPECIAL_INTERNALLY_BOUND_SYMBOL; // ← Overly clever + +// And forever prevent this: +accessor fullName = 'default'; // ❌ Would conflict with symbol detection +``` + +**Conclusion:** String arrays are simpler, more declarative, and don't constrain +future implementation choices. The loss of IntelliSense for property names is +acceptable given the philosophy of treating developers as experts who can +reference their own property names. + +## Inheritance and Decorators + +**Derived classes automatically inherit properties and their callbacks.** Base's +static methods can access Base's private fields on derived instances. + +**Key rules:** +- Private callbacks (`#method`) cannot be overridden - use for final components +- Public callbacks (`method`) can be overridden with `super` - use for extensible base classes +- Derived classes cannot access Base's private fields (true encapsulation) +- Use public extension points with private implementation (mixed pattern) for best of both worlds + +## Complete API Example + +```javascript +import { XElement, property, listener, html } from './x-element.js'; + +class MyElement extends XElement { + // Public properties (on prototype) - the only public API surface + @property({ type: String, reflect: true }) + accessor first; + + @property({ type: String }) + accessor last; + + @property({ type: Number, initial: 0 }) + accessor count; + + // Read-only property pattern (private + public computed) + @property({ type: String }) + accessor #status; + + @property({ + type: String, + input: ['#status'], + compute: (status) => status, // Identity transform + }) + accessor status; + + @property({ + input: ['first', 'last'], + // ✅ Private implementation! + compute: (first, last) => MyElement.#computeFull(first, last), + }) + accessor full; + + @property({ + type: String, + // ✅ Private implementation! + observe: (host, value) => MyElement.#observeValue(host, value), + }) + accessor value; + + // Private/internal property (on prototype) + @property({ type: String, initial: 'secret' }) + accessor #internalState; + + // Private static compute method (NO host parameter - pure function) + static #computeFull(first, last) { + return `${first} ${last}`; + } + + // Private static observer method (HAS host parameter) + static #observeValue(host, value) { + console.log(`Value changed to: ${value}`); + host.#internalState = `value-is-${value}`; + } + + // Private event listeners (HAS host parameter) + @listener('click') + static #onClick(host, event) { + host.count++; + host.#status = `Clicked ${host.count} times`; // Write to private + console.log(host.status); // Read from public computed + } + + @listener('keydown', { capture: true }) + static #onKeydown(host, event) { + console.log('key:', event.key); + } + + // Template with imported html + static template(host) { + return html` +

Hello ${host.full}!

+ + `; + } +} +``` + +**Convention: Use private static methods for all callbacks** +- Compute methods: `static #computeFoo()` +- Observers: `static #observeFoo()` +- Listeners: `static #onClick()` +- Only public properties should be on the public API surface + +## Callback Signature Summary + +| Callback Type | Signature | Reason | +|---------------|----------------------------------------------|--------------------------------------| +| **Compute** | `static #computeFoo(...inputs)` | Pure function, memoized, NO host | +| **Observe** | `static #observeFoo(host, value, oldValue)` | Needs host to interact with element | +| **Listener** | `static #onClick(host, event)` | Needs host to interact with element | + +**Note:** All callbacks should be private static methods. They are +implementation details, not public API. + +## Multiple Listeners + +With decorators, you can attach multiple `@listener()` decorators for the same +event type, each with its own method - enabling separation of concerns. +Execution order is top-to-bottom. diff --git a/eslint.config.js b/eslint.config.js index 828ea21..3249b98 100644 --- a/eslint.config.js +++ b/eslint.config.js @@ -1,6 +1,7 @@ import globals from 'globals'; import jsdoc from 'eslint-plugin-jsdoc'; import NetflixCommon from '@netflix/eslint-config'; +import babelParser from '@babel/eslint-parser'; export default [ jsdoc.configs['flat/recommended'], @@ -11,7 +12,7 @@ export default [ ignores: ['server.js', 'test.js'], }, { - files: ['x-element.js', 'x-parser.js', 'x-template.js'], + files: ['x-element.js', 'x-element-next.js', 'x-parser.js', 'x-template.js'], plugins: { jsdoc }, rules: { 'jsdoc/require-param-description': 'off', @@ -24,11 +25,22 @@ export default [ files: ['performance.js', 'server.js', 'test.js'], languageOptions: { globals: { ...globals.browser, ...globals.node } }, }, + { + files: ['**/*.src.js'], + languageOptions: { + parser: babelParser, + globals: globals.browser, + }, + }, { ignores: [ 'node_modules', - 'demo/react/index.js', // generated from .jsx file - 'performance/react/index.js', // generated from .jsx file + 'demo/react/index.js', // generated from .jsx file + 'performance/react/index.js', // generated from .jsx file + 'test-next/*.js', // transpiled decorator tests (test-next directory) + '!test-next/*.src.js', // but DO lint decorator source files + 'test/test-decorators.js', // transpiled decorator tests (for old test suite) + 'transpile-decorators.js', // build script '*.d.ts', ], }, @@ -38,6 +50,8 @@ export default [ preferredTypes: [ // TypeScript knows about this, but eslint does not. 'TemplateStringsArray', + 'AddEventListenerOptions', + 'CustomElementConstructor', ], }, }, diff --git a/package-lock.json b/package-lock.json index a7e6c7f..2291c32 100644 --- a/package-lock.json +++ b/package-lock.json @@ -9,6 +9,10 @@ "version": "2.0.0-rc.14", "license": "Apache-2.0", "devDependencies": { + "@babel/cli": "^7.28.3", + "@babel/core": "^7.28.5", + "@babel/eslint-parser": "^7.28.5", + "@babel/plugin-proposal-decorators": "^7.28.0", "@netflix/eslint-config": "3.0.0", "@netflix/x-test": "2.0.0-rc.2", "@netflix/x-test-cli": "1.0.0-rc.2", @@ -33,120 +37,491 @@ "node": ">=0.10.0" } }, + "node_modules/@babel/cli": { + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/cli/-/cli-7.28.3.tgz", + "integrity": "sha512-n1RU5vuCX0CsaqaXm9I0KUCNKNQMy5epmzl/xdSSm70bSqhg9GWhgeosypyQLc0bK24+Xpk1WGzZlI9pJtkZdg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.28", + "commander": "^6.2.0", + "convert-source-map": "^2.0.0", + "fs-readdir-recursive": "^1.1.0", + "glob": "^7.2.0", + "make-dir": "^2.1.0", + "slash": "^2.0.0" + }, + "bin": { + "babel": "bin/babel.js", + "babel-external-helpers": "bin/babel-external-helpers.js" + }, + "engines": { + "node": ">=6.9.0" + }, + "optionalDependencies": { + "@nicolo-ribaudo/chokidar-2": "2.1.8-no-fsevents.3", + "chokidar": "^3.6.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, "node_modules/@babel/code-frame": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz", - "integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==", + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.27.1.tgz", + "integrity": "sha512-cjQ7ZlQ0Mv3b47hABuTevyTuYN4i+loJKGeV9flcCgIK37cCXRh+L1bd3iBHlynerhQ7BhCkn2BPbQUL+rGqFg==", "dev": true, "license": "MIT", "dependencies": { - "@babel/highlight": "^7.18.6" + "@babel/helper-validator-identifier": "^7.27.1", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" }, "engines": { "node": ">=6.9.0" } }, - "node_modules/@babel/helper-validator-identifier": { - "version": "7.19.1", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz", - "integrity": "sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w==", + "node_modules/@babel/compat-data": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.28.5.tgz", + "integrity": "sha512-6uFXyCayocRbqhZOB+6XcuZbkMNimwfVGFji8CTZnCzOHVGvDqzvitu1re2AU5LROliz7eQPhB8CpAMvnx9EjA==", "dev": true, "license": "MIT", "engines": { "node": ">=6.9.0" } }, - "node_modules/@babel/highlight": { - "version": "7.18.6", - "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz", - "integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==", + "node_modules/@babel/core": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.28.5.tgz", + "integrity": "sha512-e7jT4DxYvIDLk1ZHmU/m/mB19rex9sv0c2ftBtjSBv+kVM/902eh0fINUzD7UwLLNR+jU585GxUJ8/EBfAM5fw==", "dev": true, "license": "MIT", "dependencies": { - "@babel/helper-validator-identifier": "^7.18.6", - "chalk": "^2.0.0", - "js-tokens": "^4.0.0" + "@babel/code-frame": "^7.27.1", + "@babel/generator": "^7.28.5", + "@babel/helper-compilation-targets": "^7.27.2", + "@babel/helper-module-transforms": "^7.28.3", + "@babel/helpers": "^7.28.4", + "@babel/parser": "^7.28.5", + "@babel/template": "^7.27.2", + "@babel/traverse": "^7.28.5", + "@babel/types": "^7.28.5", + "@jridgewell/remapping": "^2.3.5", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" }, "engines": { "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" } }, - "node_modules/@babel/highlight/node_modules/ansi-styles": { - "version": "3.2.1", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", - "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "node_modules/@babel/core/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/eslint-parser": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/eslint-parser/-/eslint-parser-7.28.5.tgz", + "integrity": "sha512-fcdRcWahONYo+JRnJg1/AekOacGvKx12Gu0qXJXFi2WBqQA1i7+O5PaxRB7kxE/Op94dExnCiiar6T09pvdHpA==", "dev": true, "license": "MIT", "dependencies": { - "color-convert": "^1.9.0" + "@nicolo-ribaudo/eslint-scope-5-internals": "5.1.1-v1", + "eslint-visitor-keys": "^2.1.0", + "semver": "^6.3.1" }, "engines": { - "node": ">=4" + "node": "^10.13.0 || ^12.13.0 || >=14.0.0" + }, + "peerDependencies": { + "@babel/core": "^7.11.0", + "eslint": "^7.5.0 || ^8.0.0 || ^9.0.0" } }, - "node_modules/@babel/highlight/node_modules/chalk": { - "version": "2.4.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", - "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "node_modules/@babel/eslint-parser/node_modules/eslint-visitor-keys": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-2.1.0.tgz", + "integrity": "sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=10" + } + }, + "node_modules/@babel/eslint-parser/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/generator": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.28.5.tgz", + "integrity": "sha512-3EwLFhZ38J4VyIP6WNtt2kUdW9dokXA9Cr4IVIFHuCpZ3H8/YFOl5JjZHisrn1fATPBmKKqXzDFvh9fUwHz6CQ==", "dev": true, "license": "MIT", "dependencies": { - "ansi-styles": "^3.2.1", - "escape-string-regexp": "^1.0.5", - "supports-color": "^5.3.0" + "@babel/parser": "^7.28.5", + "@babel/types": "^7.28.5", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" }, "engines": { - "node": ">=4" + "node": ">=6.9.0" } }, - "node_modules/@babel/highlight/node_modules/color-convert": { - "version": "1.9.3", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", - "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "node_modules/@babel/helper-annotate-as-pure": { + "version": "7.27.3", + "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.27.3.tgz", + "integrity": "sha512-fXSwMQqitTGeHLBC08Eq5yXz2m37E4pJX1qAU1+2cNedz/ifv/bVXft90VeSav5nFO61EcNgwr0aJxbyPaWBPg==", "dev": true, "license": "MIT", "dependencies": { - "color-name": "1.1.3" + "@babel/types": "^7.27.3" + }, + "engines": { + "node": ">=6.9.0" } }, - "node_modules/@babel/highlight/node_modules/color-name": { - "version": "1.1.3", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", - "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "node_modules/@babel/helper-compilation-targets": { + "version": "7.27.2", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.27.2.tgz", + "integrity": "sha512-2+1thGUUWWjLTYTHZWK1n8Yga0ijBz1XAhUXcKy81rd5g6yh7hGqMp45v7cadSbEHc9G3OTv45SyneRN3ps4DQ==", "dev": true, - "license": "MIT" + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.27.2", + "@babel/helper-validator-option": "^7.27.1", + "browserslist": "^4.24.0", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } }, - "node_modules/@babel/highlight/node_modules/escape-string-regexp": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", - "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "node_modules/@babel/helper-compilation-targets/node_modules/lru-cache": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz", + "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==", + "dev": true, + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-create-class-features-plugin": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.28.5.tgz", + "integrity": "sha512-q3WC4JfdODypvxArsJQROfupPBq9+lMwjKq7C33GhbFYJsufD0yd/ziwD+hJucLeWsnFPWZjsU2DNFqBPE7jwQ==", "dev": true, "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.27.3", + "@babel/helper-member-expression-to-functions": "^7.28.5", + "@babel/helper-optimise-call-expression": "^7.27.1", + "@babel/helper-replace-supers": "^7.27.1", + "@babel/helper-skip-transparent-expression-wrappers": "^7.27.1", + "@babel/traverse": "^7.28.5", + "semver": "^6.3.1" + }, "engines": { - "node": ">=0.8.0" + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" } }, - "node_modules/@babel/highlight/node_modules/has-flag": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", - "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "node_modules/@babel/helper-create-class-features-plugin/node_modules/semver": { + "version": "6.3.1", + "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", + "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-globals": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz", + "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==", "dev": true, "license": "MIT", "engines": { - "node": ">=4" + "node": ">=6.9.0" } }, - "node_modules/@babel/highlight/node_modules/supports-color": { - "version": "5.5.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", - "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "node_modules/@babel/helper-member-expression-to-functions": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.28.5.tgz", + "integrity": "sha512-cwM7SBRZcPCLgl8a7cY0soT1SptSzAlMH39vwiRpOQkJlh53r5hdHwLSCZpQdVLT39sZt+CRpNwYG4Y2v77atg==", "dev": true, "license": "MIT", "dependencies": { - "has-flag": "^3.0.0" + "@babel/traverse": "^7.28.5", + "@babel/types": "^7.28.5" }, "engines": { - "node": ">=4" + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.27.1.tgz", + "integrity": "sha512-0gSFWUPNXNopqtIPQvlD5WgXYI5GY2kP2cCvoT8kczjbfcfuIljTbcWrulD1CIPIX2gt1wghbDy08yE1p+/r3w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.27.1", + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.28.3", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.3.tgz", + "integrity": "sha512-gytXUbs8k2sXS9PnQptz5o0QnpLL51SwASIORY6XaBKF88nsOT0Zw9szLqlSGQDP/4TljBAD5y98p2U1fqkdsw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.27.1", + "@babel/helper-validator-identifier": "^7.27.1", + "@babel/traverse": "^7.28.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-optimise-call-expression": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.27.1.tgz", + "integrity": "sha512-URMGH08NzYFhubNSGJrpUEphGKQwMQYBySzat5cAByY1/YgIRkULnIy3tAMeszlL/so2HbeilYloUmSpd7GdVw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.27.1.tgz", + "integrity": "sha512-1gn1Up5YXka3YYAHGKpbideQ5Yjf1tDa9qYcgysz+cNCXukyLl6DjPXhD3VRwSb8c0J9tA4b2+rHEZtc6R0tlw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-replace-supers": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.27.1.tgz", + "integrity": "sha512-7EHz6qDZc8RYS5ElPoShMheWvEgERonFCs7IAonWLLUTXW59DP14bCZt89/GKyreYn8g3S83m21FelHKbeDCKA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-member-expression-to-functions": "^7.27.1", + "@babel/helper-optimise-call-expression": "^7.27.1", + "@babel/traverse": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-skip-transparent-expression-wrappers": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.27.1.tgz", + "integrity": "sha512-Tub4ZKEXqbPjXgWLl2+3JpQAYBJ8+ikpQ2Ocj/q/r0LwE3UhENh7EUabyHjz2kCEsrRY83ew2DQdHluuiDQFzg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.27.1", + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", + "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz", + "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.28.4", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.28.4.tgz", + "integrity": "sha512-HFN59MmQXGHVyYadKLVumYsA9dBFun/ldYxipEjzA4196jpLZd8UjEEBLkbEkvfYreDqJhZxYAWFPtrfhNpj4w==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/template": "^7.27.2", + "@babel/types": "^7.28.4" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.28.5.tgz", + "integrity": "sha512-KKBU1VGYR7ORr3At5HAtUQ+TV3SzRCXmA/8OdDZiLDBIZxVyzXuztPjfLd3BV1PRAQGCMWWSHYhL0F8d5uHBDQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/types": "^7.28.5" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-proposal-decorators": { + "version": "7.28.0", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-decorators/-/plugin-proposal-decorators-7.28.0.tgz", + "integrity": "sha512-zOiZqvANjWDUaUS9xMxbMcK/Zccztbe/6ikvUXaG9nsPH3w6qh5UaPGAnirI/WhIbZ8m3OHU0ReyPrknG+ZKeg==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.27.1", + "@babel/helper-plugin-utils": "^7.27.1", + "@babel/plugin-syntax-decorators": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-decorators": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-decorators/-/plugin-syntax-decorators-7.27.1.tgz", + "integrity": "sha512-YMq8Z87Lhl8EGkmb0MwYkt36QnxC+fzCgrl66ereamPlYToRpIk5nUjKUY3QKLWq8mwUB1BgbeXcTJhZOCDg5A==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/template": { + "version": "7.27.2", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.27.2.tgz", + "integrity": "sha512-LPDZ85aEJyYSd18/DkjNh4/y1ntkE5KwUHWTiqgRxruuZL2F1yuHligVHLvcHY2vMHXttKFpJn6LwfI7cw7ODw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.27.1", + "@babel/parser": "^7.27.2", + "@babel/types": "^7.27.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.28.5.tgz", + "integrity": "sha512-TCCj4t55U90khlYkVV/0TfkJkAkUg3jZFA3Neb7unZT8CPok7iiRfaX0F+WnqWqt7OxhOn0uBKXCw4lbL8W0aQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.27.1", + "@babel/generator": "^7.28.5", + "@babel/helper-globals": "^7.28.0", + "@babel/parser": "^7.28.5", + "@babel/template": "^7.27.2", + "@babel/types": "^7.28.5", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.28.5.tgz", + "integrity": "sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.28.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@es-joy/jsdoccomment": { @@ -813,6 +1188,56 @@ "url": "https://github.com/sponsors/nzakas" } }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/remapping": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz", + "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true, + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, "node_modules/@netflix/eslint-config": { "version": "3.0.0", "resolved": "https://registry.npmjs.org/@netflix/eslint-config/-/eslint-config-3.0.0.tgz", @@ -851,6 +1276,48 @@ "npm": ">=10.8" } }, + "node_modules/@nicolo-ribaudo/chokidar-2": { + "version": "2.1.8-no-fsevents.3", + "resolved": "https://registry.npmjs.org/@nicolo-ribaudo/chokidar-2/-/chokidar-2-2.1.8-no-fsevents.3.tgz", + "integrity": "sha512-s88O1aVtXftvp5bCPB7WnmXc5IwOZZ7YPuwNPt+GtOOXpPvad1LfbmjYv+qII7zP6RU2QGnqve27dnLycEnyEQ==", + "dev": true, + "license": "MIT", + "optional": true + }, + "node_modules/@nicolo-ribaudo/eslint-scope-5-internals": { + "version": "5.1.1-v1", + "resolved": "https://registry.npmjs.org/@nicolo-ribaudo/eslint-scope-5-internals/-/eslint-scope-5-internals-5.1.1-v1.tgz", + "integrity": "sha512-54/JRvkLIzzDWshCWfuhadfrfZVPiElY8Fcgmg1HroEly/EDSszzhBAsarCux+D/kOslTRquNzuyGSmUSTTHGg==", + "dev": true, + "license": "MIT", + "dependencies": { + "eslint-scope": "5.1.1" + } + }, + "node_modules/@nicolo-ribaudo/eslint-scope-5-internals/node_modules/eslint-scope": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-5.1.1.tgz", + "integrity": "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==", + "dev": true, + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/@nicolo-ribaudo/eslint-scope-5-internals/node_modules/estraverse": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.3.0.tgz", + "integrity": "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==", + "dev": true, + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, "node_modules/@puppeteer/browsers": { "version": "2.10.12", "resolved": "https://registry.npmjs.org/@puppeteer/browsers/-/browsers-2.10.12.tgz", @@ -1026,6 +1493,21 @@ "url": "https://github.com/chalk/ansi-styles?sponsor=1" } }, + "node_modules/anymatch": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz", + "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==", + "dev": true, + "license": "ISC", + "optional": true, + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, "node_modules/are-docs-informative": { "version": "0.0.2", "resolved": "https://registry.npmjs.org/are-docs-informative/-/are-docs-informative-0.0.2.tgz", @@ -1175,6 +1657,16 @@ "bare-path": "^3.0.0" } }, + "node_modules/baseline-browser-mapping": { + "version": "2.8.30", + "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.8.30.tgz", + "integrity": "sha512-aTUKW4ptQhS64+v2d6IkPzymEzzhw+G0bA1g3uBRV3+ntkH+svttKseW5IOR4Ed6NUVKqnY7qT3dKvzQ7io4AA==", + "dev": true, + "license": "Apache-2.0", + "bin": { + "baseline-browser-mapping": "dist/cli.js" + } + }, "node_modules/basic-ftp": { "version": "5.0.5", "resolved": "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.0.5.tgz", @@ -1185,6 +1677,20 @@ "node": ">=10.0.0" } }, + "node_modules/binary-extensions": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.3.0.tgz", + "integrity": "sha512-Ceh+7ox5qe7LJuLHoY0feh3pHuUDHAcRUeyL2VYghZwfpkNIy/+8Ocg0a3UuSoYzavmylwuLWQOf3hl0jjMMIw==", + "dev": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/brace-expansion": { "version": "1.1.12", "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz", @@ -1196,6 +1702,54 @@ "concat-map": "0.0.1" } }, + "node_modules/braces": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz", + "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "fill-range": "^7.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browserslist": { + "version": "4.28.0", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.0.tgz", + "integrity": "sha512-tbydkR/CxfMwelN0vwdP/pLkDwyAASZ+VfWm4EOwlB6SWhx1sYnWLqo8N5j0rAzPfzfRaxt0mM/4wPU/Su84RQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "baseline-browser-mapping": "^2.8.25", + "caniuse-lite": "^1.0.30001754", + "electron-to-chromium": "^1.5.249", + "node-releases": "^2.0.27", + "update-browserslist-db": "^1.1.4" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, "node_modules/buffer-crc32": { "version": "0.2.13", "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz", @@ -1216,6 +1770,27 @@ "node": ">=6" } }, + "node_modules/caniuse-lite": { + "version": "1.0.30001756", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001756.tgz", + "integrity": "sha512-4HnCNKbMLkLdhJz3TToeVWHSnfJvPaq6vu/eRP0Ahub/07n484XHhBF5AJoSGHdVrS8tKFauUQz8Bp9P7LVx7A==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, "node_modules/chalk": { "version": "4.1.0", "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.0.tgz", @@ -1233,6 +1808,46 @@ "url": "https://github.com/chalk/chalk?sponsor=1" } }, + "node_modules/chokidar": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz", + "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.2", + "glob-parent": "~5.1.2", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.6.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/chokidar/node_modules/glob-parent": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz", + "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==", + "dev": true, + "license": "ISC", + "optional": true, + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, "node_modules/chromium-bidi": { "version": "10.5.1", "resolved": "https://registry.npmjs.org/chromium-bidi/-/chromium-bidi-10.5.1.tgz", @@ -1282,6 +1897,16 @@ "dev": true, "license": "MIT" }, + "node_modules/commander": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-6.2.1.tgz", + "integrity": "sha512-U7VdrJFnJgo4xjrHpTzu0yrHPGImdsmD95ZlgYSEajAn2JKzDhDTPG9kBTefmObL2w/ngeZnilk+OV9CG3d7UA==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, "node_modules/comment-parser": { "version": "1.4.1", "resolved": "https://registry.npmjs.org/comment-parser/-/comment-parser-1.4.1.tgz", @@ -1299,6 +1924,13 @@ "dev": true, "license": "MIT" }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz", + "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==", + "dev": true, + "license": "MIT" + }, "node_modules/cosmiconfig": { "version": "9.0.0", "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-9.0.0.tgz", @@ -1398,6 +2030,13 @@ "dev": true, "license": "BSD-3-Clause" }, + "node_modules/electron-to-chromium": { + "version": "1.5.259", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.259.tgz", + "integrity": "sha512-I+oLXgpEJzD6Cwuwt1gYjxsDmu/S/Kd41mmLA3O+/uH2pFRO/DvOjUyGozL8j3KeLV6WyZ7ssPwELMsXCcsJAQ==", + "dev": true, + "license": "ISC" + }, "node_modules/emoji-regex": { "version": "8.0.0", "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", @@ -1849,6 +2488,20 @@ "node": ">=16.0.0" } }, + "node_modules/fill-range": { + "version": "7.1.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz", + "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, "node_modules/find-up": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", @@ -1885,6 +2538,45 @@ "integrity": "sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==", "dev": true }, + "node_modules/fs-readdir-recursive": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fs-readdir-recursive/-/fs-readdir-recursive-1.1.0.tgz", + "integrity": "sha512-GNanXlVr2pf02+sPN40XN8HG+ePaNcvM0q5mZBd668Obwb0yD5GiUbZOFgwn8kGMY6I3mdyDJzieUy3PTYyTRA==", + "dev": true, + "license": "MIT" + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true, + "license": "ISC" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz", + "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, "node_modules/get-caller-file": { "version": "2.0.5", "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", @@ -1926,6 +2618,28 @@ "node": ">= 14" } }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "deprecated": "Glob versions prior to v9 are no longer supported", + "dev": true, + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/glob-parent": { "version": "6.0.2", "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz", @@ -2057,6 +2771,25 @@ "node": ">=0.8.19" } }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.", + "dev": true, + "license": "ISC", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true, + "license": "ISC" + }, "node_modules/ip-address": { "version": "10.0.1", "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.0.1.tgz", @@ -2074,6 +2807,20 @@ "dev": true, "license": "MIT" }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz", + "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, "node_modules/is-extglob": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", @@ -2107,6 +2854,17 @@ "node": ">=0.10.0" } }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">=0.12.0" + } + }, "node_modules/isexe": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", @@ -2144,6 +2902,19 @@ "node": ">=20.0.0" } }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "dev": true, + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, "node_modules/json-buffer": { "version": "3.0.1", "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz", @@ -2171,6 +2942,19 @@ "dev": true, "license": "MIT" }, + "node_modules/json5": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz", + "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==", + "dev": true, + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, "node_modules/keyv": { "version": "4.5.4", "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz", @@ -2234,6 +3018,30 @@ "node": ">=12" } }, + "node_modules/make-dir": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-2.1.0.tgz", + "integrity": "sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==", + "dev": true, + "license": "MIT", + "dependencies": { + "pify": "^4.0.1", + "semver": "^5.6.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/make-dir/node_modules/semver": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", + "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver" + } + }, "node_modules/minimatch": { "version": "3.1.2", "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", @@ -2277,6 +3085,24 @@ "node": ">= 0.4.0" } }, + "node_modules/node-releases": { + "version": "2.0.27", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.27.tgz", + "integrity": "sha512-nmh3lCkYZ3grZvqcCH+fjmQ7X+H0OeZgP40OierEaAptX4XofMh5kwNbWh7lBduUzCcV/8kZ+NDLCwm2iorIlA==", + "dev": true, + "license": "MIT" + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz", + "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==", + "dev": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/object-deep-merge": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/object-deep-merge/-/object-deep-merge-2.0.0.tgz", @@ -2437,6 +3263,16 @@ "node": ">=8" } }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, "node_modules/path-key": { "version": "3.1.1", "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz", @@ -2454,6 +3290,37 @@ "dev": true, "license": "MIT" }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true, + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "license": "MIT", + "optional": true, + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pify": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", + "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, "node_modules/prelude-ls": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", @@ -2563,6 +3430,20 @@ "node": ">=18" } }, + "node_modules/readdirp": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz", + "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, "node_modules/require-directory": { "version": "2.1.1", "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", @@ -2632,6 +3513,16 @@ "node": ">=8" } }, + "node_modules/slash": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-2.0.0.tgz", + "integrity": "sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, "node_modules/smart-buffer": { "version": "4.2.0", "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz", @@ -2841,6 +3732,20 @@ "b4a": "^1.6.4" } }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "license": "MIT", + "optional": true, + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, "node_modules/to-valid-identifier": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/to-valid-identifier/-/to-valid-identifier-1.0.0.tgz", @@ -2907,6 +3812,37 @@ "license": "MIT", "optional": true }, + "node_modules/update-browserslist-db": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.4.tgz", + "integrity": "sha512-q0SPT4xyU84saUX+tomz1WLkxUbuaJnR1xWt17M7fJtEJigJeWUNGUqrauFXsHnqev9y9JTRGwk13tFBuKby4A==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.2.0", + "picocolors": "^1.1.1" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, "node_modules/uri-js": { "version": "4.4.1", "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", @@ -2997,6 +3933,13 @@ "node": ">=10" } }, + "node_modules/yallist": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz", + "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==", + "dev": true, + "license": "ISC" + }, "node_modules/yaml": { "version": "2.5.0", "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.5.0.tgz", diff --git a/package.json b/package.json index 2a05074..4915426 100644 --- a/package.json +++ b/package.json @@ -34,6 +34,8 @@ "build-react": "npm run build-react-demo && npm run build-react-performance", "build-react-demo": "esbuild demo/react/index.jsx --bundle --format=esm --jsx=automatic --packages=external --external:../* --outfile=demo/react/index.js", "build-react-performance": "esbuild performance/react/index.jsx --bundle --format=esm --jsx=automatic --packages=external --external:../* --outfile=performance/react/index.js", + "transpile-decorators": "node transpile-decorators.js", + "pretest": "npm run transpile-decorators", "test": "x-test --client=puppeteer --url=http://127.0.0.1:8080/test/ --coverage=true", "type": "tsc", "performance": "node ./performance.js", @@ -48,6 +50,10 @@ "/types" ], "devDependencies": { + "@babel/cli": "^7.28.3", + "@babel/core": "^7.28.5", + "@babel/eslint-parser": "^7.28.5", + "@babel/plugin-proposal-decorators": "^7.28.0", "@netflix/eslint-config": "3.0.0", "@netflix/x-test": "2.0.0-rc.2", "@netflix/x-test-cli": "1.0.0-rc.2", diff --git a/test-next/index.html b/test-next/index.html new file mode 100644 index 0000000..83e6013 --- /dev/null +++ b/test-next/index.html @@ -0,0 +1,18 @@ + + + + + + + + +

XElement Tests

+ + + diff --git a/test-next/index.js b/test-next/index.js new file mode 100644 index 0000000..18f82fe --- /dev/null +++ b/test-next/index.js @@ -0,0 +1,23 @@ +import { test } from '@netflix/x-test/x-test.js'; + +test('./test-parser.html'); +test('./test-template-engine.html'); +test('./test-analysis-errors.html'); +test('./test-initialization-errors.html'); +test('./test-attribute-changed-errors.html'); +test('./test-element-upgrade.html'); +test('./test-render.html'); +test('./test-render-root.html'); +test('./test-styles.html'); +test('./test-basic-properties.html'); +test('./test-initial-properties.html'); +test('./test-default-properties.html'); +test('./test-read-only-properties.html'); +test('./test-internal-properties.html'); +test('./test-reflected-properties.html'); +test('./test-computed-properties.html'); +test('./test-observed-properties.html'); +test('./test-listeners.html'); +test('./test-inheritance.html'); +test('./test-property-deletion.html'); +test('./test-scratch.html'); diff --git a/test-next/test-analysis-errors.html b/test-next/test-analysis-errors.html new file mode 100644 index 0000000..94203a2 --- /dev/null +++ b/test-next/test-analysis-errors.html @@ -0,0 +1,18 @@ + + + + + + + + +

Test Analysis Errors

+ + + diff --git a/test-next/test-analysis-errors.js b/test-next/test-analysis-errors.js new file mode 100644 index 0000000..fd74dce --- /dev/null +++ b/test-next/test-analysis-errors.js @@ -0,0 +1,1031 @@ +function _applyDecs(e, t, r, n, o, a) { function i(e, t, r) { return function (n, o) { return r && r(n), e[t].call(n, o); }; } function c(e, t) { for (var r = 0; r < e.length; r++) e[r].call(t); return t; } function s(e, t, r, n) { if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); return e; } function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { function m(e) { if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); } var y, v = t[0], g = t[3], b = !u; if (!b) { r || Array.isArray(v) || (v = [v]); var w = {}, S = [], A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; f ? (p || d ? w = { get: _setFunctionName(function () { return g(this); }, n, "get"), set: function (e) { t[4](this, e); } } : w[A] = g, p || _setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); } for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { var D = v[j], E = r ? v[j - 1] : void 0, I = {}, O = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: n, metadata: a, addInitializer: function (e, t) { if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); s(t, "An initializer", "be", !0), c.push(t); }.bind(null, I) }; try { if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { var k, F; O.static = l, O.private = f, f ? 2 === o ? k = function (e) { return m(e), w.value; } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function (e) { return e[n]; }, (o < 2 || 4 === o) && (F = function (e, t) { e[n] = t; })); var N = O.access = { has: f ? h.bind() : function (e) { return n in e; } }; if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { get: w.get, set: w.set } : w[A], O), d) { if ("object" == typeof P && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); } } finally { I.v = !0; } } return (p || d) && u.push(function (e, t) { for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); return t; }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; } function u(e, t) { return Object.defineProperty(e, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: !0, enumerable: !0, value: t }); } if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol.for("Symbol.metadata")]; var f = Object.create(null == l ? null : l), p = function (e, t, r, n) { var o, a, i = [], s = function (t) { return _checkInRHS(t) === e; }, u = new Map(); function l(e) { e && i.push(c.bind(null, e)); } for (var f = 0; f < t.length; f++) { var p = t[f]; if (Array.isArray(p)) { var d = p[1], h = p[2], m = p.length > 3, y = 16 & d, v = !!(8 & d), g = 0 == (d &= 7), b = h + "/" + v; if (!g && !m) { var w = u.get(b); if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); u.set(b, !(d > 2) || d); } applyDec(v ? e : e.prototype, p, y, m ? "#" + h : _toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); } } return l(o), l(a), i; }(e, t, o, f); return r.length || u(e, f), { e: p, get c() { var t = []; return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; } }; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; } +function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; } +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, listener } from '../x-element-next.js'; +it('properties should not have hyphens (conflicts with attribute names)', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto, _computedKeyDecs, _init_computedKey; + class TestElement extends XElement { + static { + [_init_computedKey, _initProto] = _applyDecs(this, [[_computedKeyDecs, 1, 'just-stop']], [], 0, void 0, XElement).e; + } + #A = (_initProto(this), _init_computedKey(this)); + get [(_computedKeyDecs = property({ + type: String + }), 'just-stop')]() { + return this.#A; + } + set 'just-stop'(v) { + this.#A = v; + } + } + customElements.define('test-element-hyphen', TestElement); + } catch (error) { + // Note: With decorators, the error message may be different as we're + // decorating a quoted property name which might fail at the decorator level + passed = true; + message = error.message; + } + assert(passed, message); +}); +it('property attributes should not have non-standard casing', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto2, _okDecs, _init_ok; + class TestElement extends XElement { + static { + [_init_ok, _initProto2] = _applyDecs(this, [[_okDecs, 1, "ok"]], [], 0, void 0, XElement).e; + } + #A = (_initProto2(this), _init_ok(this)); + get [(_okDecs = property({ + type: String, + attribute: 'this-IS-not-OK' + }), "ok")]() { + return this.#A; + } + set ok(v) { + this.#A = v; + } + } + customElements.define('test-element-attr-case', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.ok has non-standard attribute casing "this-IS-not-OK" (use lower-cased names).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('properties should not shadow XElement prototype interface', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto3, _dispatchErrorDecs, _init_dispatchError; + class TestElement extends XElement { + static { + [_init_dispatchError, _initProto3] = _applyDecs(this, [[_dispatchErrorDecs, 1, "dispatchError"]], [], 0, void 0, XElement).e; + } + #A = (_initProto3(this), _init_dispatchError(this)); + get [(_dispatchErrorDecs = property({}), "dispatchError")]() { + return this.#A; + } + set dispatchError(v) { + this.#A = v; + } + } + customElements.define('test-element-shadow', TestElement); + } catch (error) { + const expected = 'Unexpected key "TestElement.prototype.dispatchError" shadows in XElement.prototype interface.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('property keys should only be from our known set', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto4, _badPropertyDecs, _init_badProperty; + class TestElement extends XElement { + static { + [_init_badProperty, _initProto4] = _applyDecs(this, [[_badPropertyDecs, 1, "badProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto4(this), _init_badProperty(this)); + get [(_badPropertyDecs = property({ + doesNotExist: true + }), "badProperty")]() { + return this.#A; + } + set badProperty(v) { + this.#A = v; + } + } + customElements.define('test-element-bad-key', TestElement); + } catch (error) { + const expected = 'Unexpected key "TestElement.prototype.badProperty.doesNotExist".'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('properties should be objects', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto5, _badPropertyDecs2, _init_badProperty2; + class TestElement extends XElement { + static { + [_init_badProperty2, _initProto5] = _applyDecs(this, [[_badPropertyDecs2, 1, "badProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto5(this), _init_badProperty2(this)); + get [(_badPropertyDecs2 = property(undefined), "badProperty")]() { + return this.#A; + } + set badProperty(v) { + this.#A = v; + } + } + customElements.define('test-element-bad-prop-type', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.badProperty has an unexpected value (expected Object, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('type should be a function', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto6, _badTypeDecs, _init_badType; + class TestElement extends XElement { + static { + [_init_badType, _initProto6] = _applyDecs(this, [[_badTypeDecs, 1, "badType"]], [], 0, void 0, XElement).e; + } + #A = (_initProto6(this), _init_badType(this)); + get [(_badTypeDecs = property({ + type: undefined + }), "badType")]() { + return this.#A; + } + set badType(v) { + this.#A = v; + } + } + customElements.define('test-element-bad-type', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badType.type" (expected constructor Function, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('compute should be a function', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto7, _badComputeDecs, _init_badCompute; + class TestElement extends XElement { + static { + [_init_badCompute, _initProto7] = _applyDecs(this, [[_badComputeDecs, 1, "badCompute"]], [], 0, void 0, XElement).e; + } + #A = (_initProto7(this), _init_badCompute(this)); + get [(_badComputeDecs = property({ + compute: undefined + }), "badCompute")]() { + return this.#A; + } + set badCompute(v) { + this.#A = v; + } + } + customElements.define('test-element-bad-compute', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badCompute.compute" (expected Function, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('observe should be a function', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto8, _badObserveDecs, _init_badObserve; + class TestElement extends XElement { + static { + [_init_badObserve, _initProto8] = _applyDecs(this, [[_badObserveDecs, 1, "badObserve"]], [], 0, void 0, XElement).e; + } + #A = (_initProto8(this), _init_badObserve(this)); + get [(_badObserveDecs = property({ + observe: undefined + }), "badObserve")]() { + return this.#A; + } + set badObserve(v) { + this.#A = v; + } + } + customElements.define('test-element-bad-observe', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badObserve.observe" (expected Function, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('attribute should be a string', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto9, _badAttributeDecs, _init_badAttribute; + class TestElement extends XElement { + static { + [_init_badAttribute, _initProto9] = _applyDecs(this, [[_badAttributeDecs, 1, "badAttribute"]], [], 0, void 0, XElement).e; + } + #A = (_initProto9(this), _init_badAttribute(this)); + get [(_badAttributeDecs = property({ + attribute: undefined + }), "badAttribute")]() { + return this.#A; + } + set badAttribute(v) { + this.#A = v; + } + } + customElements.define('test-element-bad-attr', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badAttribute.attribute" (expected String, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('attribute should be a non-empty string', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto0, _badAttributeDecs2, _init_badAttribute2; + class TestElement extends XElement { + static { + [_init_badAttribute2, _initProto0] = _applyDecs(this, [[_badAttributeDecs2, 1, "badAttribute"]], [], 0, void 0, XElement).e; + } + #A = (_initProto0(this), _init_badAttribute2(this)); + get [(_badAttributeDecs2 = property({ + attribute: '' + }), "badAttribute")]() { + return this.#A; + } + set badAttribute(v) { + this.#A = v; + } + } + customElements.define('test-element-empty-attr', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badAttribute.attribute" (expected non-empty String).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('attributes cannot be duplicated (1)', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto1, _attributeDecs, _init_attribute, _aliasedDecs, _init_aliased; + class TestElement extends XElement { + static { + [_init_attribute, _init_aliased, _initProto1] = _applyDecs(this, [[_attributeDecs, 1, "attribute"], [_aliasedDecs, 1, "aliased"]], [], 0, void 0, XElement).e; + } + #A = (_initProto1(this), _init_attribute(this)); + get [(_attributeDecs = property({ + type: String + }), _aliasedDecs = property({ + type: String, + attribute: 'attribute' + }), "attribute")]() { + return this.#A; + } + set attribute(v) { + this.#A = v; + } + #B = _init_aliased(this); + get aliased() { + return this.#B; + } + set aliased(v) { + this.#B = v; + } + } + customElements.define('test-element-dup-attr-1', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.aliased causes a duplicated attribute "attribute".'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('attributes cannot be duplicated (2)', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto10, _attributeDecs2, _init_attribute2, _aliasedDecs2, _init_aliased2; + class TestElement extends XElement { + static { + [_init_attribute2, _init_aliased2, _initProto10] = _applyDecs(this, [[_attributeDecs2, 1, "attribute"], [_aliasedDecs2, 1, "aliased"]], [], 0, void 0, XElement).e; + } + #A = (_initProto10(this), _init_attribute2(this)); + get [(_attributeDecs2 = property({}), _aliasedDecs2 = property({ + attribute: 'attribute' + }), "attribute")]() { + return this.#A; + } + set attribute(v) { + this.#A = v; + } + #B = _init_aliased2(this); + get aliased() { + return this.#B; + } + set aliased(v) { + this.#B = v; + } + } + customElements.define('test-element-dup-attr-2', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.aliased causes a duplicated attribute "attribute".'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('default must be a scalar or a function', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto11, _badValueDecs, _init_badValue; + class TestElement extends XElement { + static { + [_init_badValue, _initProto11] = _applyDecs(this, [[_badValueDecs, 1, "badValue"]], [], 0, void 0, XElement).e; + } + #A = (_initProto11(this), _init_badValue(this)); + get [(_badValueDecs = property({ + default: {} + }), "badValue")]() { + return this.#A; + } + set badValue(v) { + this.#A = v; + } + } + customElements.define('test-element-bad-default', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badValue.default" (expected Boolean, String, Number, or Function, got Object).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('reflect should be a boolean', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto12, _badReflectDecs, _init_badReflect; + class TestElement extends XElement { + static { + [_init_badReflect, _initProto12] = _applyDecs(this, [[_badReflectDecs, 1, "badReflect"]], [], 0, void 0, XElement).e; + } + #A = (_initProto12(this), _init_badReflect(this)); + get [(_badReflectDecs = property({ + reflect: undefined + }), "badReflect")]() { + return this.#A; + } + set badReflect(v) { + this.#A = v; + } + } + customElements.define('test-element-bad-reflect', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badReflect.reflect" (expected Boolean, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: The internal configuration doesn't exist in the decorator API. +// Users should use private fields to achieve internal property behavior. +// Skip this test as internal configuration is not supported with decorators. +it.skip('internal should be a boolean', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto13, _badInternalDecs, _init_badInternal; + class TestElement extends XElement { + static { + [_init_badInternal, _initProto13] = _applyDecs(this, [[_badInternalDecs, 1, "badInternal"]], [], 0, void 0, XElement).e; + } + #A = (_initProto13(this), _init_badInternal(this)); + get [(_badInternalDecs = property({ + internal: undefined + }), "badInternal")]() { + return this.#A; + } + set badInternal(v) { + this.#A = v; + } + } + customElements.define('test-element-bad-internal', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badInternal.internal" (expected Boolean, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: The readOnly configuration doesn't exist in the decorator API. +// Instead, users should use accessor-only decorators (no setter) or private +// fields with a getter accessor to achieve read-only behavior. Skip this test +// as readOnly configuration is not supported with decorators. +it.skip('readOnly should be a boolean', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + static get properties() { + return { + badReadOnly: { + readOnly: undefined + } + }; + } + } + customElements.define('test-element-bad-readonly', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badReadOnly.readOnly" (expected Boolean, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('input should be an array', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto14, _badInputDecs, _init_badInput; + class TestElement extends XElement { + static { + [_init_badInput, _initProto14] = _applyDecs(this, [[_badInputDecs, 1, "badInput"]], [], 0, void 0, XElement).e; + } + #A = (_initProto14(this), _init_badInput(this)); + get [(_badInputDecs = property({ + input: {} + }), "badInput")]() { + return this.#A; + } + set badInput(v) { + this.#A = v; + } + } + customElements.define('test-element-bad-input-type', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badInput.input" (expected Array, got Object).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('input items should be strings', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto15, _badInputDecs2, _init_badInput2; + class TestElement extends XElement { + static { + [_init_badInput2, _initProto15] = _applyDecs(this, [[_badInputDecs2, 1, "badInput"]], [], 0, void 0, XElement).e; + } + #A = (_initProto15(this), _init_badInput2(this)); + get [(_badInputDecs2 = property({ + input: ['foo', 'bar', undefined] + }), "badInput")]() { + return this.#A; + } + set badInput(v) { + this.#A = v; + } + } + customElements.define('test-element-bad-input-items', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badInput.input[2]" (expected String, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('input keys cannot be duplicated', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto16, _fooDecs, _init_foo, _computedDecs, _init_computed; + class TestElement extends XElement { + static { + [_init_foo, _init_computed, _initProto16] = _applyDecs(this, [[_fooDecs, 1, "foo"], [_computedDecs, 1, "computed"]], [], 0, void 0, XElement).e; + } + #A = (_initProto16(this), _init_foo(this)); + get [(_fooDecs = property({ + type: String + }), _computedDecs = property({ + input: ['foo', 'foo'], + compute: () => {} + }), "foo")]() { + return this.#A; + } + set foo(v) { + this.#A = v; + } + #B = _init_computed(this); + get computed() { + return this.#B; + } + set computed(v) { + this.#B = v; + } + } + customElements.define('test-element-duplicate-input', TestElement); + } catch (error) { + const expected = 'Duplicate key "foo" in "TestElement.prototype.computed.input" (each input key must be unique).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('input must be declared as other property names', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto17, _fooDecs2, _init_foo2, _badInputDecs3, _init_badInput3; + class TestElement extends XElement { + static { + [_init_foo2, _init_badInput3, _initProto17] = _applyDecs(this, [[_fooDecs2, 1, "foo"], [_badInputDecs3, 1, "badInput"]], [], 0, void 0, XElement).e; + } + #A = (_initProto17(this), _init_foo2(this)); + get [(_fooDecs2 = property({}), _badInputDecs3 = property({ + input: ['foo', 'bar'], + compute: () => {} + }), "foo")]() { + return this.#A; + } + set foo(v) { + this.#A = v; + } + #B = _init_badInput3(this); + get badInput() { + return this.#B; + } + set badInput(v) { + this.#B = v; + } + } + customElements.define('test-element-undeclared-input', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.badInput.input[1] has an unexpected item ("bar" cannot be resolved).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('input cannot be cyclic (simple)', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto18, _simpleCycleDecs, _init_simpleCycle; + class TestElement extends XElement { + static { + [_init_simpleCycle, _initProto18] = _applyDecs(this, [[_simpleCycleDecs, 1, "simpleCycle"]], [], 0, void 0, XElement).e; + } + #A = (_initProto18(this), _init_simpleCycle(this)); + get [(_simpleCycleDecs = property({ + input: ['simpleCycle'], + compute: () => {} + }), "simpleCycle")]() { + return this.#A; + } + set simpleCycle(v) { + this.#A = v; + } + } + customElements.define('test-element-simple-cycle', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.simpleCycle.input is cyclic.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('input cannot be cyclic (complex)', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto19, _aDecs, _init_a, _bDecs, _init_b, _cDecs, _init_c; + class TestElement extends XElement { + static { + [_init_a, _init_b, _init_c, _initProto19] = _applyDecs(this, [[_aDecs, 1, "a"], [_bDecs, 1, "b"], [_cDecs, 1, "c"]], [], 0, void 0, XElement).e; + } + #A = (_initProto19(this), _init_a(this)); + get [(_aDecs = property({ + input: ['c'], + compute: () => {} + }), _bDecs = property({ + input: ['a'], + compute: () => {} + }), _cDecs = property({ + input: ['b'], + compute: () => {} + }), "a")]() { + return this.#A; + } + set a(v) { + this.#A = v; + } + #B = _init_b(this); + get b() { + return this.#B; + } + set b(v) { + this.#B = v; + } + #C = _init_c(this); + get c() { + return this.#C; + } + set c(v) { + this.#C = v; + } + } + customElements.define('test-element-complex-cycle', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.a.input is cyclic.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('attribute cannot be declared on unserializable types', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto20, _unserializableDecs, _init_unserializable; + class TestElement extends XElement { + static { + [_init_unserializable, _initProto20] = _applyDecs(this, [[_unserializableDecs, 1, "unserializable"]], [], 0, void 0, XElement).e; + } + #A = (_initProto20(this), _init_unserializable(this)); + get [(_unserializableDecs = property({ + type: Function, + attribute: 'nope' + }), "unserializable")]() { + return this.#A; + } + set unserializable(v) { + this.#A = v; + } + } + customElements.define('test-element-unserializable', TestElement); + } catch (error) { + const expected = 'Found unserializable "TestElement.prototype.unserializable.type" (Function) but "TestElement.prototype.unserializable.attribute" is defined.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('input cannot be declared without a compute callback', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto21, _missingComputeDecs, _init_missingCompute; + class TestElement extends XElement { + static { + [_init_missingCompute, _initProto21] = _applyDecs(this, [[_missingComputeDecs, 1, "missingCompute"]], [], 0, void 0, XElement).e; + } + #A = (_initProto21(this), _init_missingCompute(this)); + get [(_missingComputeDecs = property({ + input: ['foo', 'bar', 'baz'] + }), "missingCompute")]() { + return this.#A; + } + set missingCompute(v) { + this.#A = v; + } + } + customElements.define('test-element-missing-compute', TestElement); + } catch (error) { + const expected = 'Found "TestElement.prototype.missingCompute.input" without "TestElement.prototype.missingCompute.compute" (computed properties require a compute callback).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('compute cannot be declared without an input callback', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto22, _missingInputDecs, _init_missingInput; + class TestElement extends XElement { + static { + [_init_missingInput, _initProto22] = _applyDecs(this, [[_missingInputDecs, 1, "missingInput"]], [], 0, void 0, XElement).e; + } + #A = (_initProto22(this), _init_missingInput(this)); + get [(_missingInputDecs = property({ + compute: () => {} + }), "missingInput")]() { + return this.#A; + } + set missingInput(v) { + this.#A = v; + } + } + customElements.define('test-element-missing-input', TestElement); + } catch (error) { + const expected = 'Found "TestElement.prototype.missingInput.compute" without "TestElement.prototype.missingInput.input" (computed properties require input).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('initial cannot be declared for a computed property', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto23, _unexpectedValueDecs, _init_unexpectedValue; + class TestElement extends XElement { + static { + [_init_unexpectedValue, _initProto23] = _applyDecs(this, [[_unexpectedValueDecs, 1, "unexpectedValue"]], [], 0, void 0, XElement).e; + } + #A = (_initProto23(this), _init_unexpectedValue(this)); + get [(_unexpectedValueDecs = property({ + compute: () => {}, + input: [], + initial: 5 + }), "unexpectedValue")]() { + return this.#A; + } + set unexpectedValue(v) { + this.#A = v; + } + } + customElements.define('test-element-computed-initial', TestElement); + } catch (error) { + const expected = 'Found "TestElement.prototype.unexpectedValue.initial" and "TestElement.prototype.unexpectedValue.compute" (computed properties cannot set an initial value).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: The readOnly configuration doesn't exist in the decorator API. +// This test validates that computed properties cannot be readOnly, but since +// readOnly doesn't exist in decorators, skip this test. +it.skip('readOnly cannot be declared for a computed property', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + static get properties() { + return { + unexpectedValue: { + compute: () => {}, + input: [], + readOnly: true + } + }; + } + } + customElements.define('test-element-computed-readonly', TestElement); + } catch (error) { + const expected = 'Found "TestElement.prototype.unexpectedValue.readOnly" and "TestElement.prototype.unexpectedValue.compute" (computed properties cannot define read-only).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: The readOnly configuration doesn't exist in the decorator API. +// This test validates that internal properties cannot be readOnly, but since +// readOnly doesn't exist in decorators, skip this test. +it.skip('internal properties cannot also be readOnly', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + static get properties() { + return { + internalReadOnlyProperty: { + type: String, + internal: true, + readOnly: true + } + }; + } + } + customElements.define('test-element-internal-readonly', TestElement); + } catch (error) { + const expected = 'Both "TestElement.prototype.internalReadOnlyProperty.internal" and "TestElement.prototype.internalReadOnlyProperty.readOnly" are true (read-only properties cannot be internal).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('internal properties cannot also be reflected', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto24, _internalReflectedPropertyDecs, _init_internalReflectedProperty, _get_internalReflectedProperty, _set_internalReflectedProperty; + class TestElement extends XElement { + static [(_internalReflectedPropertyDecs = property({ + type: String, + reflect: true + }), "_")]; + static { + delete this._; + [_init_internalReflectedProperty, _get_internalReflectedProperty, _set_internalReflectedProperty, _initProto24] = _applyDecs(this, [[_internalReflectedPropertyDecs, 1, "internalReflectedProperty", o => o.#A, (o, v) => o.#A = v]], [], 0, _ => #internalReflectedProperty in _, XElement).e; + } + #A = (_initProto24(this), _init_internalReflectedProperty(this)); + set #internalReflectedProperty(v) { + _set_internalReflectedProperty(this, v); + } + get #internalReflectedProperty() { + return _get_internalReflectedProperty(this); + } + } + customElements.define('test-element-internal-reflect', TestElement); + } catch (error) { + const expected = 'Found "TestElement.prototype.#internalReflectedProperty.reflect" but property is private (private properties cannot be reflected).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('internal properties cannot define an attribute', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto25, _internalAttributePropertyDecs, _init_internalAttributeProperty, _get_internalAttributeProperty, _set_internalAttributeProperty; + class TestElement extends XElement { + static [(_internalAttributePropertyDecs = property({ + type: String, + attribute: 'custom-attribute' + }), "_")]; + static { + delete this._; + [_init_internalAttributeProperty, _get_internalAttributeProperty, _set_internalAttributeProperty, _initProto25] = _applyDecs(this, [[_internalAttributePropertyDecs, 1, "internalAttributeProperty", o => o.#A, (o, v) => o.#A = v]], [], 0, _ => #internalAttributeProperty in _, XElement).e; + } + #A = (_initProto25(this), _init_internalAttributeProperty(this)); + set #internalAttributeProperty(v) { + _set_internalAttributeProperty(this, v); + } + get #internalAttributeProperty() { + return _get_internalAttributeProperty(this); + } + } + customElements.define('test-element-internal-attr', TestElement); + } catch (error) { + const expected = 'Found "TestElement.prototype.#internalAttributeProperty.attribute" but property is private (private properties cannot have attributes).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('reflected properties must have serializable type', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto26, _nonSerializablePropertyDecs, _init_nonSerializableProperty; + class TestElement extends XElement { + static { + [_init_nonSerializableProperty, _initProto26] = _applyDecs(this, [[_nonSerializablePropertyDecs, 1, "nonSerializableProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto26(this), _init_nonSerializableProperty(this)); + get [(_nonSerializablePropertyDecs = property({ + type: Object, + reflect: true + }), "nonSerializableProperty")]() { + return this.#A; + } + set nonSerializableProperty(v) { + this.#A = v; + } + } + customElements.define('test-element-reflect-nonserialized', TestElement); + } catch (error) { + const expected = 'Found unserializable "TestElement.prototype.nonSerializableProperty.type" (Object) but "TestElement.prototype.nonSerializableProperty.reflect" is true.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('reflected properties must have serializable type (2)', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto27, _typelessPropertyDecs, _init_typelessProperty; + class TestElement extends XElement { + static { + [_init_typelessProperty, _initProto27] = _applyDecs(this, [[_typelessPropertyDecs, 1, "typelessProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto27(this), _init_typelessProperty(this)); + get [(_typelessPropertyDecs = property({ + reflect: true + }), "typelessProperty")]() { + return this.#A; + } + set typelessProperty(v) { + this.#A = v; + } + } + customElements.define('test-element-reflect-typeless', TestElement); + } catch (error) { + const expected = 'Found unserializable "TestElement.prototype.typelessProperty.type" (Undefined) but "TestElement.prototype.typelessProperty.reflect" is true.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('listeners as an object should map to functions', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _fooDecs3, _init_foo3; + class TestElement extends XElement { + static { + [_init_foo3] = _applyDecs(this, [[_fooDecs3, 8, "foo"]], [], 0, void 0, XElement).e; + } + // With decorators, this error would be caught differently since we + // can't decorate non-functions. This test might need to be updated + // to test the decorator API's validation. + static [(_fooDecs3 = listener('click'), "foo")] = _init_foo3(this, undefined); + } + customElements.define('test-element-bad-listener', TestElement); + } catch (error) { + // The error message will be different with decorators + passed = true; + message = error.message; + } + assert(passed, message); +}); +it('listener options should be an object', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initStatic, _onClickDecs; + class TestElement extends XElement { + static { + [_initStatic] = _applyDecs(this, [[_onClickDecs, 10, "onClick"]], [], 0, void 0, XElement).e; + _initStatic(this); + } + static [(_onClickDecs = listener('click', 'not-an-object'), "onClick")]() {} + } + customElements.define('test-element-bad-options', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.onClick" options (expected Object, got String).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: This is a temporary limitation of the babel decorator +// transpiler. We will be able to invert this test later to prove that we can +// in fact use the same private property names in parent and child. +it('cannot use same private property name in parent and child', () => { + let passed = false; + let message = 'no error was thrown'; + try { + let _initProto28, _fieldDecs, _init_field, _get_field, _set_field, _initProto29, _fieldDecs2, _init_field2, _get_field2, _set_field2; + class ParentElement extends XElement { + static [(_fieldDecs = property({ + type: String + }), "_")]; + static { + delete this._; + [_init_field, _get_field, _set_field, _initProto28] = _applyDecs(this, [[_fieldDecs, 1, "field", o => o.#A, (o, v) => o.#A = v]], [], 0, _ => #field in _, XElement).e; + } + #A = (_initProto28(this), _init_field(this)); + set #field(v) { + _set_field(this, v); + } + get #field() { + return _get_field(this); + } + } + class ChildElement extends ParentElement { + static [(_fieldDecs2 = property({ + type: String + }), "_")]; + static { + delete this._; + [_init_field2, _get_field2, _set_field2, _initProto29] = _applyDecs(this, [[_fieldDecs2, 1, "field", o => o.#A, (o, v) => o.#A = v]], [], 0, _ => #field in _, ParentElement).e; + } + #A = (_initProto29(this), _init_field2(this)); + set #field(v) { + _set_field2(this, v); + } + get #field() { + return _get_field2(this); + } + } + customElements.define('test-private-collision', ChildElement); + } catch (error) { + const expected = 'ChildElement: Cannot use private property "#field" in both parent and child classes.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["assert","it","XElement","property","listener","passed","message","_initProto","_computedKeyDecs","_init_computedKey","TestElement","_applyDecs","e","A","type","String","just-stop","v","customElements","define","error","_initProto2","_okDecs","_init_ok","attribute","ok","expected","_initProto3","_dispatchErrorDecs","_init_dispatchError","dispatchError","_initProto4","_badPropertyDecs","_init_badProperty","doesNotExist","badProperty","_initProto5","_badPropertyDecs2","_init_badProperty2","undefined","_initProto6","_badTypeDecs","_init_badType","badType","_initProto7","_badComputeDecs","_init_badCompute","compute","badCompute","_initProto8","_badObserveDecs","_init_badObserve","observe","badObserve","_initProto9","_badAttributeDecs","_init_badAttribute","badAttribute","_initProto0","_badAttributeDecs2","_init_badAttribute2","_initProto1","_attributeDecs","_init_attribute","_aliasedDecs","_init_aliased","B","aliased","_initProto10","_attributeDecs2","_init_attribute2","_aliasedDecs2","_init_aliased2","_initProto11","_badValueDecs","_init_badValue","default","badValue","_initProto12","_badReflectDecs","_init_badReflect","reflect","badReflect","skip","_initProto13","_badInternalDecs","_init_badInternal","internal","badInternal","properties","badReadOnly","readOnly","_initProto14","_badInputDecs","_init_badInput","input","badInput","_initProto15","_badInputDecs2","_init_badInput2","_initProto16","_fooDecs","_init_foo","_computedDecs","_init_computed","foo","computed","_initProto17","_fooDecs2","_init_foo2","_badInputDecs3","_init_badInput3","_initProto18","_simpleCycleDecs","_init_simpleCycle","simpleCycle","_initProto19","_aDecs","_init_a","_bDecs","_init_b","_cDecs","_init_c","a","b","C","c","_initProto20","_unserializableDecs","_init_unserializable","Function","unserializable","_initProto21","_missingComputeDecs","_init_missingCompute","missingCompute","_initProto22","_missingInputDecs","_init_missingInput","missingInput","_initProto23","_unexpectedValueDecs","_init_unexpectedValue","initial","unexpectedValue","internalReadOnlyProperty","_initProto24","_internalReflectedPropertyDecs","_init_internalReflectedProperty","_get_internalReflectedProperty","_set_internalReflectedProperty","_","o","internalReflectedProperty","#internalReflectedProperty","_initProto25","_internalAttributePropertyDecs","_init_internalAttributeProperty","_get_internalAttributeProperty","_set_internalAttributeProperty","internalAttributeProperty","#internalAttributeProperty","_initProto26","_nonSerializablePropertyDecs","_init_nonSerializableProperty","Object","nonSerializableProperty","_initProto27","_typelessPropertyDecs","_init_typelessProperty","typelessProperty","_fooDecs3","_init_foo3","_initStatic","_onClickDecs","_initProto28","_fieldDecs","_init_field","_get_field","_set_field","_initProto29","_fieldDecs2","_init_field2","_get_field2","_set_field2","ParentElement","field","#field","ChildElement"],"sources":["test-analysis-errors.src.js"],"sourcesContent":["import { assert, it } from '@netflix/x-test/x-test.js';\nimport { XElement, property, listener } from '../x-element-next.js';\n\nit('properties should not have hyphens (conflicts with attribute names)', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ type: String })\n      accessor 'just-stop';\n    }\n    customElements.define('test-element-hyphen', TestElement);\n  } catch (error) {\n    // Note: With decorators, the error message may be different as we're\n    // decorating a quoted property name which might fail at the decorator level\n    passed = true;\n    message = error.message;\n  }\n  assert(passed, message);\n});\n\nit('property attributes should not have non-standard casing', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ type: String, attribute: 'this-IS-not-OK' })\n      accessor ok;\n    }\n    customElements.define('test-element-attr-case', TestElement);\n  } catch (error) {\n    const expected = 'TestElement.prototype.ok has non-standard attribute casing \"this-IS-not-OK\" (use lower-cased names).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('properties should not shadow XElement prototype interface', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({})\n      accessor dispatchError;\n    }\n    customElements.define('test-element-shadow', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected key \"TestElement.prototype.dispatchError\" shadows in XElement.prototype interface.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('property keys should only be from our known set', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ doesNotExist: true })\n      accessor badProperty;\n    }\n    customElements.define('test-element-bad-key', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected key \"TestElement.prototype.badProperty.doesNotExist\".';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('properties should be objects', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property(undefined)\n      accessor badProperty;\n    }\n    customElements.define('test-element-bad-prop-type', TestElement);\n  } catch (error) {\n    const expected = 'TestElement.prototype.badProperty has an unexpected value (expected Object, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('type should be a function', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ type: undefined })\n      accessor badType;\n    }\n    customElements.define('test-element-bad-type', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected value for \"TestElement.prototype.badType.type\" (expected constructor Function, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('compute should be a function', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ compute: undefined })\n      accessor badCompute;\n    }\n    customElements.define('test-element-bad-compute', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected value for \"TestElement.prototype.badCompute.compute\" (expected Function, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('observe should be a function', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ observe: undefined })\n      accessor badObserve;\n    }\n    customElements.define('test-element-bad-observe', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected value for \"TestElement.prototype.badObserve.observe\" (expected Function, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('attribute should be a string', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ attribute: undefined })\n      accessor badAttribute;\n    }\n    customElements.define('test-element-bad-attr', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected value for \"TestElement.prototype.badAttribute.attribute\" (expected String, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('attribute should be a non-empty string', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ attribute: '' })\n      accessor badAttribute;\n    }\n    customElements.define('test-element-empty-attr', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected value for \"TestElement.prototype.badAttribute.attribute\" (expected non-empty String).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('attributes cannot be duplicated (1)', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ type: String })\n      accessor attribute;\n\n      @property({ type: String, attribute: 'attribute' })\n      accessor aliased;\n    }\n    customElements.define('test-element-dup-attr-1', TestElement);\n  } catch (error) {\n    const expected = 'TestElement.prototype.aliased causes a duplicated attribute \"attribute\".';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('attributes cannot be duplicated (2)', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({})\n      accessor attribute;\n\n      @property({ attribute: 'attribute' })\n      accessor aliased;\n    }\n    customElements.define('test-element-dup-attr-2', TestElement);\n  } catch (error) {\n    const expected = 'TestElement.prototype.aliased causes a duplicated attribute \"attribute\".';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('default must be a scalar or a function', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ default: {} })\n      accessor badValue;\n    }\n    customElements.define('test-element-bad-default', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected value for \"TestElement.prototype.badValue.default\" (expected Boolean, String, Number, or Function, got Object).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('reflect should be a boolean', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ reflect: undefined })\n      accessor badReflect;\n    }\n    customElements.define('test-element-bad-reflect', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected value for \"TestElement.prototype.badReflect.reflect\" (expected Boolean, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: The internal configuration doesn't exist in the decorator API.\n//  Users should use private fields to achieve internal property behavior.\n//  Skip this test as internal configuration is not supported with decorators.\nit.skip('internal should be a boolean', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ internal: undefined })\n      accessor badInternal;\n    }\n    customElements.define('test-element-bad-internal', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected value for \"TestElement.prototype.badInternal.internal\" (expected Boolean, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: The readOnly configuration doesn't exist in the decorator API.\n//  Instead, users should use accessor-only decorators (no setter) or private\n//  fields with a getter accessor to achieve read-only behavior. Skip this test\n//  as readOnly configuration is not supported with decorators.\nit.skip('readOnly should be a boolean', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      static get properties() {\n        return { badReadOnly: { readOnly: undefined } };\n      }\n    }\n    customElements.define('test-element-bad-readonly', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected value for \"TestElement.prototype.badReadOnly.readOnly\" (expected Boolean, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('input should be an array', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ input: {} })\n      accessor badInput;\n    }\n    customElements.define('test-element-bad-input-type', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected value for \"TestElement.prototype.badInput.input\" (expected Array, got Object).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('input items should be strings', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ input: ['foo', 'bar', undefined] })\n      accessor badInput;\n    }\n    customElements.define('test-element-bad-input-items', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected value for \"TestElement.prototype.badInput.input[2]\" (expected String, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('input keys cannot be duplicated', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ type: String })\n      accessor foo;\n\n      @property({ input: ['foo', 'foo'], compute: () => {} })\n      accessor computed;\n    }\n    customElements.define('test-element-duplicate-input', TestElement);\n  } catch (error) {\n    const expected = 'Duplicate key \"foo\" in \"TestElement.prototype.computed.input\" (each input key must be unique).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('input must be declared as other property names', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({})\n      accessor foo;\n\n      @property({ input: ['foo', 'bar'], compute: () => {} })\n      accessor badInput;\n    }\n    customElements.define('test-element-undeclared-input', TestElement);\n  } catch (error) {\n    const expected = 'TestElement.prototype.badInput.input[1] has an unexpected item (\"bar\" cannot be resolved).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('input cannot be cyclic (simple)', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ input: ['simpleCycle'], compute: () => {} })\n      accessor simpleCycle;\n    }\n    customElements.define('test-element-simple-cycle', TestElement);\n  } catch (error) {\n    const expected = 'TestElement.prototype.simpleCycle.input is cyclic.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('input cannot be cyclic (complex)', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ input: ['c'], compute: () => {} })\n      accessor a;\n\n      @property({ input: ['a'], compute: () => {} })\n      accessor b;\n\n      @property({ input: ['b'], compute: () => {} })\n      accessor c;\n    }\n    customElements.define('test-element-complex-cycle', TestElement);\n  } catch (error) {\n    const expected = 'TestElement.prototype.a.input is cyclic.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('attribute cannot be declared on unserializable types', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ type: Function, attribute: 'nope' })\n      accessor unserializable;\n    }\n    customElements.define('test-element-unserializable', TestElement);\n  } catch (error) {\n    const expected = 'Found unserializable \"TestElement.prototype.unserializable.type\" (Function) but \"TestElement.prototype.unserializable.attribute\" is defined.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('input cannot be declared without a compute callback', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ input: ['foo', 'bar', 'baz'] })\n      accessor missingCompute;\n    }\n    customElements.define('test-element-missing-compute', TestElement);\n  } catch (error) {\n    const expected = 'Found \"TestElement.prototype.missingCompute.input\" without \"TestElement.prototype.missingCompute.compute\" (computed properties require a compute callback).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('compute cannot be declared without an input callback', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ compute: () => {} })\n      accessor missingInput;\n    }\n    customElements.define('test-element-missing-input', TestElement);\n  } catch (error) {\n    const expected = 'Found \"TestElement.prototype.missingInput.compute\" without \"TestElement.prototype.missingInput.input\" (computed properties require input).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('initial cannot be declared for a computed property', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({ compute: () => {}, input: [], initial: 5 })\n      accessor unexpectedValue;\n    }\n    customElements.define('test-element-computed-initial', TestElement);\n  } catch (error) {\n    const expected = 'Found \"TestElement.prototype.unexpectedValue.initial\" and \"TestElement.prototype.unexpectedValue.compute\" (computed properties cannot set an initial value).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: The readOnly configuration doesn't exist in the decorator API.\n//  This test validates that computed properties cannot be readOnly, but since\n//  readOnly doesn't exist in decorators, skip this test.\nit.skip('readOnly cannot be declared for a computed property', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      static get properties() {\n        return { unexpectedValue: { compute: () => {}, input: [], readOnly: true } };\n      }\n    }\n    customElements.define('test-element-computed-readonly', TestElement);\n  } catch (error) {\n    const expected = 'Found \"TestElement.prototype.unexpectedValue.readOnly\" and \"TestElement.prototype.unexpectedValue.compute\" (computed properties cannot define read-only).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: The readOnly configuration doesn't exist in the decorator API.\n//  This test validates that internal properties cannot be readOnly, but since\n//  readOnly doesn't exist in decorators, skip this test.\nit.skip('internal properties cannot also be readOnly', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      static get properties() {\n        return {\n          internalReadOnlyProperty: {\n            type: String,\n            internal: true,\n            readOnly: true,\n          },\n        };\n      }\n    }\n    customElements.define('test-element-internal-readonly', TestElement);\n  } catch (error) {\n    const expected = 'Both \"TestElement.prototype.internalReadOnlyProperty.internal\" and \"TestElement.prototype.internalReadOnlyProperty.readOnly\" are true (read-only properties cannot be internal).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('internal properties cannot also be reflected', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({\n        type: String,\n        reflect: true,\n      })\n      accessor #internalReflectedProperty;\n    }\n    customElements.define('test-element-internal-reflect', TestElement);\n  } catch (error) {\n    const expected = 'Found \"TestElement.prototype.#internalReflectedProperty.reflect\" but property is private (private properties cannot be reflected).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('internal properties cannot define an attribute', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({\n        type: String,\n        attribute: 'custom-attribute',\n      })\n      accessor #internalAttributeProperty;\n    }\n    customElements.define('test-element-internal-attr', TestElement);\n  } catch (error) {\n    const expected = 'Found \"TestElement.prototype.#internalAttributeProperty.attribute\" but property is private (private properties cannot have attributes).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('reflected properties must have serializable type', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({\n        type: Object,\n        reflect: true,\n      })\n      accessor nonSerializableProperty;\n    }\n    customElements.define('test-element-reflect-nonserialized', TestElement);\n  } catch (error) {\n    const expected = 'Found unserializable \"TestElement.prototype.nonSerializableProperty.type\" (Object) but \"TestElement.prototype.nonSerializableProperty.reflect\" is true.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('reflected properties must have serializable type (2)', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @property({\n        reflect: true,\n      })\n      accessor typelessProperty;\n    }\n    customElements.define('test-element-reflect-typeless', TestElement);\n  } catch (error) {\n    const expected = 'Found unserializable \"TestElement.prototype.typelessProperty.type\" (Undefined) but \"TestElement.prototype.typelessProperty.reflect\" is true.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('listeners as an object should map to functions', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      // With decorators, this error would be caught differently since we\n      // can't decorate non-functions. This test might need to be updated\n      // to test the decorator API's validation.\n      @listener('click')\n      static foo = undefined;\n    }\n    customElements.define('test-element-bad-listener', TestElement);\n  } catch (error) {\n    // The error message will be different with decorators\n    passed = true;\n    message = error.message;\n  }\n  assert(passed, message);\n});\n\nit('listener options should be an object', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class TestElement extends XElement {\n      @listener('click', 'not-an-object')\n      static onClick() {}\n    }\n    customElements.define('test-element-bad-options', TestElement);\n  } catch (error) {\n    const expected = 'Unexpected value for \"TestElement.onClick\" options (expected Object, got String).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: This is a temporary limitation of the babel decorator\n//  transpiler. We will be able to invert this test later to prove that we can\n//  in fact use the same private property names in parent and child.\nit('cannot use same private property name in parent and child', () => {\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    class ParentElement extends XElement {\n      @property({ type: String })\n      accessor #field;\n    }\n\n    class ChildElement extends ParentElement {\n      @property({ type: String })\n      accessor #field;\n    }\n\n    customElements.define('test-private-collision', ChildElement);\n  } catch (error) {\n    const expected = 'ChildElement: Cannot use private property \"#field\" in both parent and child classes.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/test-next/test-analysis-errors.src.js b/test-next/test-analysis-errors.src.js new file mode 100644 index 0000000..678bcb4 --- /dev/null +++ b/test-next/test-analysis-errors.src.js @@ -0,0 +1,661 @@ +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, listener } from '../x-element-next.js'; + +it('properties should not have hyphens (conflicts with attribute names)', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ type: String }) + accessor 'just-stop'; + } + customElements.define('test-element-hyphen', TestElement); + } catch (error) { + // Note: With decorators, the error message may be different as we're + // decorating a quoted property name which might fail at the decorator level + passed = true; + message = error.message; + } + assert(passed, message); +}); + +it('property attributes should not have non-standard casing', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ type: String, attribute: 'this-IS-not-OK' }) + accessor ok; + } + customElements.define('test-element-attr-case', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.ok has non-standard attribute casing "this-IS-not-OK" (use lower-cased names).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('properties should not shadow XElement prototype interface', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({}) + accessor dispatchError; + } + customElements.define('test-element-shadow', TestElement); + } catch (error) { + const expected = 'Unexpected key "TestElement.prototype.dispatchError" shadows in XElement.prototype interface.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('property keys should only be from our known set', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ doesNotExist: true }) + accessor badProperty; + } + customElements.define('test-element-bad-key', TestElement); + } catch (error) { + const expected = 'Unexpected key "TestElement.prototype.badProperty.doesNotExist".'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('properties should be objects', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property(undefined) + accessor badProperty; + } + customElements.define('test-element-bad-prop-type', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.badProperty has an unexpected value (expected Object, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('type should be a function', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ type: undefined }) + accessor badType; + } + customElements.define('test-element-bad-type', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badType.type" (expected constructor Function, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('compute should be a function', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ compute: undefined }) + accessor badCompute; + } + customElements.define('test-element-bad-compute', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badCompute.compute" (expected Function, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('observe should be a function', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ observe: undefined }) + accessor badObserve; + } + customElements.define('test-element-bad-observe', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badObserve.observe" (expected Function, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('attribute should be a string', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ attribute: undefined }) + accessor badAttribute; + } + customElements.define('test-element-bad-attr', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badAttribute.attribute" (expected String, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('attribute should be a non-empty string', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ attribute: '' }) + accessor badAttribute; + } + customElements.define('test-element-empty-attr', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badAttribute.attribute" (expected non-empty String).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('attributes cannot be duplicated (1)', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ type: String }) + accessor attribute; + + @property({ type: String, attribute: 'attribute' }) + accessor aliased; + } + customElements.define('test-element-dup-attr-1', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.aliased causes a duplicated attribute "attribute".'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('attributes cannot be duplicated (2)', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({}) + accessor attribute; + + @property({ attribute: 'attribute' }) + accessor aliased; + } + customElements.define('test-element-dup-attr-2', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.aliased causes a duplicated attribute "attribute".'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('default must be a scalar or a function', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ default: {} }) + accessor badValue; + } + customElements.define('test-element-bad-default', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badValue.default" (expected Boolean, String, Number, or Function, got Object).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('reflect should be a boolean', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ reflect: undefined }) + accessor badReflect; + } + customElements.define('test-element-bad-reflect', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badReflect.reflect" (expected Boolean, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: The internal configuration doesn't exist in the decorator API. +// Users should use private fields to achieve internal property behavior. +// Skip this test as internal configuration is not supported with decorators. +it.skip('internal should be a boolean', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ internal: undefined }) + accessor badInternal; + } + customElements.define('test-element-bad-internal', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badInternal.internal" (expected Boolean, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: The readOnly configuration doesn't exist in the decorator API. +// Instead, users should use accessor-only decorators (no setter) or private +// fields with a getter accessor to achieve read-only behavior. Skip this test +// as readOnly configuration is not supported with decorators. +it.skip('readOnly should be a boolean', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + static get properties() { + return { badReadOnly: { readOnly: undefined } }; + } + } + customElements.define('test-element-bad-readonly', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badReadOnly.readOnly" (expected Boolean, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('input should be an array', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ input: {} }) + accessor badInput; + } + customElements.define('test-element-bad-input-type', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badInput.input" (expected Array, got Object).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('input items should be strings', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ input: ['foo', 'bar', undefined] }) + accessor badInput; + } + customElements.define('test-element-bad-input-items', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.badInput.input[2]" (expected String, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('input keys cannot be duplicated', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ type: String }) + accessor foo; + + @property({ input: ['foo', 'foo'], compute: () => {} }) + accessor computed; + } + customElements.define('test-element-duplicate-input', TestElement); + } catch (error) { + const expected = 'Duplicate key "foo" in "TestElement.prototype.computed.input" (each input key must be unique).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('input must be declared as other property names', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({}) + accessor foo; + + @property({ input: ['foo', 'bar'], compute: () => {} }) + accessor badInput; + } + customElements.define('test-element-undeclared-input', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.badInput.input[1] has an unexpected item ("bar" cannot be resolved).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('input cannot be cyclic (simple)', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ input: ['simpleCycle'], compute: () => {} }) + accessor simpleCycle; + } + customElements.define('test-element-simple-cycle', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.simpleCycle.input is cyclic.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('input cannot be cyclic (complex)', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ input: ['c'], compute: () => {} }) + accessor a; + + @property({ input: ['a'], compute: () => {} }) + accessor b; + + @property({ input: ['b'], compute: () => {} }) + accessor c; + } + customElements.define('test-element-complex-cycle', TestElement); + } catch (error) { + const expected = 'TestElement.prototype.a.input is cyclic.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('attribute cannot be declared on unserializable types', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ type: Function, attribute: 'nope' }) + accessor unserializable; + } + customElements.define('test-element-unserializable', TestElement); + } catch (error) { + const expected = 'Found unserializable "TestElement.prototype.unserializable.type" (Function) but "TestElement.prototype.unserializable.attribute" is defined.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('input cannot be declared without a compute callback', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ input: ['foo', 'bar', 'baz'] }) + accessor missingCompute; + } + customElements.define('test-element-missing-compute', TestElement); + } catch (error) { + const expected = 'Found "TestElement.prototype.missingCompute.input" without "TestElement.prototype.missingCompute.compute" (computed properties require a compute callback).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('compute cannot be declared without an input callback', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ compute: () => {} }) + accessor missingInput; + } + customElements.define('test-element-missing-input', TestElement); + } catch (error) { + const expected = 'Found "TestElement.prototype.missingInput.compute" without "TestElement.prototype.missingInput.input" (computed properties require input).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('initial cannot be declared for a computed property', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ compute: () => {}, input: [], initial: 5 }) + accessor unexpectedValue; + } + customElements.define('test-element-computed-initial', TestElement); + } catch (error) { + const expected = 'Found "TestElement.prototype.unexpectedValue.initial" and "TestElement.prototype.unexpectedValue.compute" (computed properties cannot set an initial value).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: The readOnly configuration doesn't exist in the decorator API. +// This test validates that computed properties cannot be readOnly, but since +// readOnly doesn't exist in decorators, skip this test. +it.skip('readOnly cannot be declared for a computed property', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + static get properties() { + return { unexpectedValue: { compute: () => {}, input: [], readOnly: true } }; + } + } + customElements.define('test-element-computed-readonly', TestElement); + } catch (error) { + const expected = 'Found "TestElement.prototype.unexpectedValue.readOnly" and "TestElement.prototype.unexpectedValue.compute" (computed properties cannot define read-only).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: The readOnly configuration doesn't exist in the decorator API. +// This test validates that internal properties cannot be readOnly, but since +// readOnly doesn't exist in decorators, skip this test. +it.skip('internal properties cannot also be readOnly', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + static get properties() { + return { + internalReadOnlyProperty: { + type: String, + internal: true, + readOnly: true, + }, + }; + } + } + customElements.define('test-element-internal-readonly', TestElement); + } catch (error) { + const expected = 'Both "TestElement.prototype.internalReadOnlyProperty.internal" and "TestElement.prototype.internalReadOnlyProperty.readOnly" are true (read-only properties cannot be internal).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('internal properties cannot also be reflected', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ + type: String, + reflect: true, + }) + accessor #internalReflectedProperty; + } + customElements.define('test-element-internal-reflect', TestElement); + } catch (error) { + const expected = 'Found "TestElement.prototype.#internalReflectedProperty.reflect" but property is private (private properties cannot be reflected).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('internal properties cannot define an attribute', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ + type: String, + attribute: 'custom-attribute', + }) + accessor #internalAttributeProperty; + } + customElements.define('test-element-internal-attr', TestElement); + } catch (error) { + const expected = 'Found "TestElement.prototype.#internalAttributeProperty.attribute" but property is private (private properties cannot have attributes).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('reflected properties must have serializable type', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ + type: Object, + reflect: true, + }) + accessor nonSerializableProperty; + } + customElements.define('test-element-reflect-nonserialized', TestElement); + } catch (error) { + const expected = 'Found unserializable "TestElement.prototype.nonSerializableProperty.type" (Object) but "TestElement.prototype.nonSerializableProperty.reflect" is true.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('reflected properties must have serializable type (2)', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @property({ + reflect: true, + }) + accessor typelessProperty; + } + customElements.define('test-element-reflect-typeless', TestElement); + } catch (error) { + const expected = 'Found unserializable "TestElement.prototype.typelessProperty.type" (Undefined) but "TestElement.prototype.typelessProperty.reflect" is true.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('listeners as an object should map to functions', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + // With decorators, this error would be caught differently since we + // can't decorate non-functions. This test might need to be updated + // to test the decorator API's validation. + @listener('click') + static foo = undefined; + } + customElements.define('test-element-bad-listener', TestElement); + } catch (error) { + // The error message will be different with decorators + passed = true; + message = error.message; + } + assert(passed, message); +}); + +it('listener options should be an object', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class TestElement extends XElement { + @listener('click', 'not-an-object') + static onClick() {} + } + customElements.define('test-element-bad-options', TestElement); + } catch (error) { + const expected = 'Unexpected value for "TestElement.onClick" options (expected Object, got String).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: This is a temporary limitation of the babel decorator +// transpiler. We will be able to invert this test later to prove that we can +// in fact use the same private property names in parent and child. +it('cannot use same private property name in parent and child', () => { + let passed = false; + let message = 'no error was thrown'; + try { + class ParentElement extends XElement { + @property({ type: String }) + accessor #field; + } + + class ChildElement extends ParentElement { + @property({ type: String }) + accessor #field; + } + + customElements.define('test-private-collision', ChildElement); + } catch (error) { + const expected = 'ChildElement: Cannot use private property "#field" in both parent and child classes.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); diff --git a/test-next/test-attribute-changed-errors.html b/test-next/test-attribute-changed-errors.html new file mode 100644 index 0000000..4f4e508 --- /dev/null +++ b/test-next/test-attribute-changed-errors.html @@ -0,0 +1,18 @@ + + + + + + + + +

Test Attribute Changed Errors

+ + + diff --git a/test-next/test-attribute-changed-errors.js b/test-next/test-attribute-changed-errors.js new file mode 100644 index 0000000..9edbf40 --- /dev/null +++ b/test-next/test-attribute-changed-errors.js @@ -0,0 +1,71 @@ +function _applyDecs(e, t, r, n, o, a) { function i(e, t, r) { return function (n, o) { return r && r(n), e[t].call(n, o); }; } function c(e, t) { for (var r = 0; r < e.length; r++) e[r].call(t); return t; } function s(e, t, r, n) { if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); return e; } function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { function m(e) { if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); } var y, v = t[0], g = t[3], b = !u; if (!b) { r || Array.isArray(v) || (v = [v]); var w = {}, S = [], A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; f ? (p || d ? w = { get: _setFunctionName(function () { return g(this); }, n, "get"), set: function (e) { t[4](this, e); } } : w[A] = g, p || _setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); } for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { var D = v[j], E = r ? v[j - 1] : void 0, I = {}, O = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: n, metadata: a, addInitializer: function (e, t) { if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); s(t, "An initializer", "be", !0), c.push(t); }.bind(null, I) }; try { if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { var k, F; O.static = l, O.private = f, f ? 2 === o ? k = function (e) { return m(e), w.value; } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function (e) { return e[n]; }, (o < 2 || 4 === o) && (F = function (e, t) { e[n] = t; })); var N = O.access = { has: f ? h.bind() : function (e) { return n in e; } }; if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { get: w.get, set: w.set } : w[A], O), d) { if ("object" == typeof P && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); } } finally { I.v = !0; } } return (p || d) && u.push(function (e, t) { for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); return t; }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; } function u(e, t) { return Object.defineProperty(e, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: !0, enumerable: !0, value: t }); } if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol.for("Symbol.metadata")]; var f = Object.create(null == l ? null : l), p = function (e, t, r, n) { var o, a, i = [], s = function (t) { return _checkInRHS(t) === e; }, u = new Map(); function l(e) { e && i.push(c.bind(null, e)); } for (var f = 0; f < t.length; f++) { var p = t[f]; if (Array.isArray(p)) { var d = p[1], h = p[2], m = p.length > 3, y = 16 & d, v = !!(8 & d), g = 0 == (d &= 7), b = h + "/" + v; if (!g && !m) { var w = u.get(b); if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); u.set(b, !(d > 2) || d); } applyDec(v ? e : e.prototype, p, y, m ? "#" + h : _toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); } } return l(o), l(a), i; }(e, t, o, f); return r.length || u(e, f), { e: p, get c() { var t = []; return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; } }; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; } +function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; } +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property } from '../x-element-next.js'; + +// TODO: #346: The readOnly configuration doesn't exist in the decorator API. +// Users should use accessor-only decorators (no setter) or private fields +// to achieve read-only behavior. Skip this test as readOnly is not supported. +it.skip('errors are thrown in attributeChangedCallback for read-only properties', () => { + // We cannot try-catch setAttribute, so we fake the attributeChangedCallback. + class TestElement extends XElement { + static get properties() { + return { + readOnlyProperty: { + type: String, + readOnly: true + } + }; + } + } + customElements.define('test-element-2', TestElement); + const el = new TestElement(); + let passed = false; + let message = 'no error was thrown'; + el.connectedCallback(); + try { + el.attributeChangedCallback('read-only-property', null, 'nope'); + } catch (error) { + const expected = 'Property "TestElement.prototype.readOnlyProperty" is read-only.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('errors are thrown in attributeChangedCallback for computed properties', () => { + let _initProto, _computedDecs, _init_computed; + // We cannot try-catch setAttribute, so we fake the attributeChangedCallback. + class TestElement extends XElement { + static { + [_init_computed, _initProto] = _applyDecs(this, [[_computedDecs, 1, "computed"]], [], 0, void 0, XElement).e; + } + #A = (_initProto(this), _init_computed(this)); + get [(_computedDecs = property({ + type: String, + input: [], + compute: () => {} + }), "computed")]() { + return this.#A; + } + set computed(v) { + this.#A = v; + } + } + customElements.define('test-element-attr-computed', TestElement); + const el = new TestElement(); + el.connectedCallback(); + let passed = false; + let message = 'no error was thrown'; + try { + el.attributeChangedCallback('computed', null, 'nope'); + } catch (error) { + const expected = 'Property "TestElement.prototype.computed" is computed (computed properties are read-only).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,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 \ No newline at end of file diff --git a/test-next/test-attribute-changed-errors.src.js b/test-next/test-attribute-changed-errors.src.js new file mode 100644 index 0000000..2da1485 --- /dev/null +++ b/test-next/test-attribute-changed-errors.src.js @@ -0,0 +1,57 @@ +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property } from '../x-element-next.js'; + +// TODO: #346: The readOnly configuration doesn't exist in the decorator API. +// Users should use accessor-only decorators (no setter) or private fields +// to achieve read-only behavior. Skip this test as readOnly is not supported. +it.skip('errors are thrown in attributeChangedCallback for read-only properties', () => { + // We cannot try-catch setAttribute, so we fake the attributeChangedCallback. + class TestElement extends XElement { + static get properties() { + return { + readOnlyProperty: { + type: String, + readOnly: true, + }, + }; + } + } + customElements.define('test-element-2', TestElement); + const el = new TestElement(); + let passed = false; + let message = 'no error was thrown'; + el.connectedCallback(); + try { + el.attributeChangedCallback('read-only-property', null, 'nope'); + } catch (error) { + const expected = 'Property "TestElement.prototype.readOnlyProperty" is read-only.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('errors are thrown in attributeChangedCallback for computed properties', () => { + // We cannot try-catch setAttribute, so we fake the attributeChangedCallback. + class TestElement extends XElement { + @property({ + type: String, + input: [], + compute: () => {}, + }) + accessor computed; + } + customElements.define('test-element-attr-computed', TestElement); + const el = new TestElement(); + el.connectedCallback(); + let passed = false; + let message = 'no error was thrown'; + try { + el.attributeChangedCallback('computed', null, 'nope'); + } catch (error) { + const expected = 'Property "TestElement.prototype.computed" is computed (computed properties are read-only).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); diff --git a/test-next/test-basic-properties.html b/test-next/test-basic-properties.html new file mode 100644 index 0000000..df6a73b --- /dev/null +++ b/test-next/test-basic-properties.html @@ -0,0 +1,18 @@ + + + + + + + + +

Test Basic Properties

+ + + diff --git a/test-next/test-basic-properties.js b/test-next/test-basic-properties.js new file mode 100644 index 0000000..3fae66d --- /dev/null +++ b/test-next/test-basic-properties.js @@ -0,0 +1,703 @@ +let _initProto, _normalPropertyDecs, _init_normalProperty, _objectPropertyDecs, _init_objectProperty, _camelCasePropertyDecs, _init_camelCaseProperty, _numericPropertyDecs, _init_numericProperty, _nullPropertyDecs, _init_nullProperty, _undefinedPropertyDecs, _init_undefinedProperty, _typelessPropertyDecs, _init_typelessProperty, _typelessPropertyWithCustomAttributeDecs, _init_typelessPropertyWithCustomAttribute, _internalPropertyDecs, _init_internalProperty, _get_internalProperty, _set_internalProperty; +function _applyDecs(e, t, r, n, o, a) { function i(e, t, r) { return function (n, o) { return r && r(n), e[t].call(n, o); }; } function c(e, t) { for (var r = 0; r < e.length; r++) e[r].call(t); return t; } function s(e, t, r, n) { if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); return e; } function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { function m(e) { if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); } var y, v = t[0], g = t[3], b = !u; if (!b) { r || Array.isArray(v) || (v = [v]); var w = {}, S = [], A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; f ? (p || d ? w = { get: _setFunctionName(function () { return g(this); }, n, "get"), set: function (e) { t[4](this, e); } } : w[A] = g, p || _setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); } for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { var D = v[j], E = r ? v[j - 1] : void 0, I = {}, O = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: n, metadata: a, addInitializer: function (e, t) { if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); s(t, "An initializer", "be", !0), c.push(t); }.bind(null, I) }; try { if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { var k, F; O.static = l, O.private = f, f ? 2 === o ? k = function (e) { return m(e), w.value; } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function (e) { return e[n]; }, (o < 2 || 4 === o) && (F = function (e, t) { e[n] = t; })); var N = O.access = { has: f ? h.bind() : function (e) { return n in e; } }; if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { get: w.get, set: w.set } : w[A], O), d) { if ("object" == typeof P && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); } } finally { I.v = !0; } } return (p || d) && u.push(function (e, t) { for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); return t; }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; } function u(e, t) { return Object.defineProperty(e, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: !0, enumerable: !0, value: t }); } if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol.for("Symbol.metadata")]; var f = Object.create(null == l ? null : l), p = function (e, t, r, n) { var o, a, i = [], s = function (t) { return _checkInRHS(t) === e; }, u = new Map(); function l(e) { e && i.push(c.bind(null, e)); } for (var f = 0; f < t.length; f++) { var p = t[f]; if (Array.isArray(p)) { var d = p[1], h = p[2], m = p.length > 3, y = 16 & d, v = !!(8 & d), g = 0 == (d &= 7), b = h + "/" + v; if (!g && !m) { var w = u.get(b); if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); u.set(b, !(d > 2) || d); } applyDec(v ? e : e.prototype, p, y, m ? "#" + h : _toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); } } return l(o), l(a), i; }(e, t, o, f); return r.length || u(e, f), { e: p, get c() { var t = []; return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; } }; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; } +function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; } +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; +class TestElementNext extends XElement { + static { + [_init_normalProperty, _init_objectProperty, _init_camelCaseProperty, _init_numericProperty, _init_nullProperty, _init_undefinedProperty, _init_typelessProperty, _init_typelessPropertyWithCustomAttribute, _init_internalProperty, _get_internalProperty, _set_internalProperty, _initProto] = _applyDecs(this, [[_normalPropertyDecs, 1, "normalProperty"], [_objectPropertyDecs, 1, "objectProperty"], [_camelCasePropertyDecs, 1, "camelCaseProperty"], [_numericPropertyDecs, 1, "numericProperty"], [_nullPropertyDecs, 1, "nullProperty"], [_undefinedPropertyDecs, 1, "undefinedProperty"], [_typelessPropertyDecs, 1, "typelessProperty"], [_typelessPropertyWithCustomAttributeDecs, 1, "typelessPropertyWithCustomAttribute"], [_internalPropertyDecs, 1, "internalProperty", o => o.#I, (o, v) => o.#I = v]], [], 0, _ => #internalProperty in _, XElement).e; + } + #A = (_initProto(this), _init_normalProperty(this)); + get [(_normalPropertyDecs = property({ + type: String, + initial: 'Ferus' + }), _objectPropertyDecs = property({ + type: Object + }), _camelCasePropertyDecs = property({ + type: String, + initial: 'Bactrian' + }), _numericPropertyDecs = property({ + type: Number, + default: 10 + }), _nullPropertyDecs = property({ + type: String, + default: null + }), _undefinedPropertyDecs = property({ + type: String + }), _typelessPropertyDecs = property({}), _typelessPropertyWithCustomAttributeDecs = property({ + attribute: 'custom-attribute-typeless' + }), _internalPropertyDecs = property({}), "normalProperty")]() { + return this.#A; + } + set normalProperty(v) { + this.#A = v; + } + #B = _init_objectProperty(this); + get objectProperty() { + return this.#B; + } + set objectProperty(v) { + this.#B = v; + } + #C = _init_camelCaseProperty(this); + get camelCaseProperty() { + return this.#C; + } + set camelCaseProperty(v) { + this.#C = v; + } + #D = _init_numericProperty(this); + get numericProperty() { + return this.#D; + } + set numericProperty(v) { + this.#D = v; + } + #E = _init_nullProperty(this); + get nullProperty() { + return this.#E; + } + set nullProperty(v) { + this.#E = v; + } + #F = _init_undefinedProperty(this); + get undefinedProperty() { + return this.#F; + } + set undefinedProperty(v) { + this.#F = v; + } + #G = _init_typelessProperty(this); + get typelessProperty() { + return this.#G; + } + set typelessProperty(v) { + this.#G = v; + } + #H = _init_typelessPropertyWithCustomAttribute(this); + get typelessPropertyWithCustomAttribute() { + return this.#H; + } + set typelessPropertyWithCustomAttribute(v) { + this.#H = v; + } + #I = _init_internalProperty(this); + set #internalProperty(v) { + _set_internalProperty(this, v); + } + get #internalProperty() { + return _get_internalProperty(this); + } + static template(host) { + return html` +
${host.normalProperty}
+ ${host.camelCaseProperty} + ${host.numericProperty} + ${host.nullProperty} + ${host.undefinedProperty} + `; + } +} +customElements.define('test-element-next', TestElementNext); +it('initialization', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.shadowRoot.getElementById('normal').textContent === 'Ferus'); + assert(el.shadowRoot.getElementById('camel').textContent === 'Bactrian'); + assert(el.shadowRoot.getElementById('num').textContent === '10'); + assert(el.shadowRoot.getElementById('nul').textContent === ''); +}); +it('renders an empty string in place of null value', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.shadowRoot.getElementById('nul').textContent === ''); +}); +it('renders an empty string in place of undefined value', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.shadowRoot.getElementById('undef').textContent === ''); +}); +it('property setter updates on next micro tick after connect', async () => { + const el = document.createElement('test-element-next'); + el.camelCaseProperty = 'Nonconforming'; + + // Initial render happens synchronously after initial connection. + document.body.append(el); + assert(el.shadowRoot.getElementById('camel').textContent === 'Nonconforming'); + + // Updates are debounced on a microtask, so they are not immediately seen. + el.camelCaseProperty = 'Dromedary'; + assert(el.shadowRoot.getElementById('camel').textContent === 'Nonconforming'); + + // After the microtask runs, the update is handled. + await Promise.resolve(); + assert(el.shadowRoot.getElementById('camel').textContent === 'Dromedary'); +}); +it('property setter renders blank value', async () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.camelCaseProperty = ''; + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.shadowRoot.getElementById('camel').textContent === ''); + el.camelCaseProperty = 'Bactrian'; + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.shadowRoot.getElementById('camel').textContent === 'Bactrian'); +}); +it('observes all dash-cased versions of public, typeless, serializable, and declared properties', () => { + const el = document.createElement('test-element-next'); + const expected = ['normal-property', 'camel-case-property', 'numeric-property', 'null-property', 'undefined-property', 'typeless-property', 'custom-attribute-typeless']; + const actual = el.constructor.observedAttributes; + assert(expected.length === actual.length); + assert(expected.every(attribute => actual.includes(attribute))); +}); +it('removeAttribute renders blank', async () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.removeAttribute('camel-case-property'); + + // We must await a microtask for the update to take place. + await Promise.resolve(); + // Note, in general, changing non-reflected properties via attributes can + // be problematic. For example, attributeChangedCallback is not fired if the + // attribute does not change. + assert(el.shadowRoot.getElementById('camel').textContent !== ''); + el.setAttribute('camel-case-property', 'foo'); + el.removeAttribute('camel-case-property'); + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.shadowRoot.getElementById('camel').textContent === ''); +}); +it('setAttribute renders the new value', async () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.setAttribute('camel-case-property', 'Racing Camel'); + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.shadowRoot.getElementById('camel').textContent === 'Racing Camel'); +}); +it('coerces attributes to the specified type', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.setAttribute('numeric-property', '-99'); + assert(el.numericProperty === -99); +}); +it('allows properties without types', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + for (const value of [{}, 'foo', '5', [], 2]) { + el.typelessProperty = value; + assert(el.typelessProperty === value); + } +}); +it('syncs attributes to properties without types', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + const value = '123'; + el.setAttribute('typeless-property', value); + assert(el.typelessProperty === value); +}); +it('initializes from attributes on connect', () => { + const el = document.createElement('test-element-next'); + el.setAttribute('camel-case-property', 'Dromedary'); + document.body.append(el); + assert(el.camelCaseProperty === 'Dromedary'); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. +it('can use "has" api or "in" operator.', () => { + let _initProto2, _normalPropertyDecs2, _init_normalProperty2; + class TempTestElement extends XElement { + static { + [_init_normalProperty2, _initProto2] = _applyDecs(this, [[_normalPropertyDecs2, 1, "normalProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto2(this), _init_normalProperty2(this)); + get [(_normalPropertyDecs2 = property({ + type: String + }), "normalProperty")]() { + return this.#A; + } + set normalProperty(v) { + this.#A = v; + } + static template(host) { + if (!('normalProperty' in host) || Reflect.has(host, 'normalProperty') === false) { + throw new Error('The "has" trap does not work.'); + } + return html``; + } + } + customElements.define('temp-test-element-next-1', TempTestElement); + const el = new TempTestElement(); + let passed = false; + let message; + try { + el.connectedCallback(); + passed = true; + } catch (error) { + message = error.message; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. In this case, ownKeys doesn’t +// work because properties are simply on the `host.prototype`. +it.skip('can use "ownKeys" api.', () => { + let _initProto3, _normalPropertyDecs3, _init_normalProperty3; + class TempTestElement extends XElement { + static { + [_init_normalProperty3, _initProto3] = _applyDecs(this, [[_normalPropertyDecs3, 1, "normalProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto3(this), _init_normalProperty3(this)); + get [(_normalPropertyDecs3 = property({ + type: String + }), "normalProperty")]() { + return this.#A; + } + set normalProperty(v) { + this.#A = v; + } + static template(host) { + const ownKeys = Reflect.ownKeys(host); + if (ownKeys.length !== 1 || ownKeys[0] !== 'normalProperty') { + throw new Error('The "ownKeys" trap does not work.'); + } + return html``; + } + } + customElements.define('temp-test-element-next-2', TempTestElement); + const el = new TempTestElement(); + let passed = false; + let message; + try { + el.connectedCallback(); + passed = true; + } catch (error) { + message = error.message; + } + assert(passed, message); +}); +it('can be read', async () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.normalProperty === 'Ferus', 'property was read'); + el.normalProperty = 'Dromedary'; + assert(el.normalProperty === 'Dromedary', 'property was written to'); + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.shadowRoot.getElementById('normal').textContent === 'Dromedary'); +}); +it('inheritance is considered in type checking', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + const array = []; + el.objectProperty = array; + assert(el.objectProperty === array, 'property was set'); +}); +it('numeric properties deserialize "" (empty) to "NaN"', () => { + const el = document.createElement('test-element-next'); + el.setAttribute('numeric-property', '0'); + document.body.append(el); + assert(el.numericProperty === 0, '"0" was coerced to 0'); + el.setAttribute('numeric-property', ''); + assert(Number.isNaN(el.numericProperty), '"" was coerced to NaN'); + el.setAttribute('numeric-property', ' '); + assert(Number.isNaN(el.numericProperty), '" " was coerced to NaN'); + el.setAttribute('numeric-property', ' '); + assert(Number.isNaN(el.numericProperty), '" " was coerced to NaN'); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. In this case, we expect our +// users to be experts and not update properties in the render loop. +it.skip('cannot set to known properties', () => { + let _initProto4, _normalPropertyDecs4, _init_normalProperty4; + class BadTestElement extends XElement { + static { + [_init_normalProperty4, _initProto4] = _applyDecs(this, [[_normalPropertyDecs4, 1, "normalProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto4(this), _init_normalProperty4(this)); + get [(_normalPropertyDecs4 = property({ + type: String + }), "normalProperty")]() { + return this.#A; + } + set normalProperty(v) { + this.#A = v; + } + static template(host) { + host.normalProperty = 'Dromedary'; + return html`
${host.normalProperty}
`; + } + } + customElements.define('bad-test-element-next-1', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Cannot set "BadTestElement.properties.normalProperty" via "properties".'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. In this case, we expect our +// users to be experts and not update properties in the render loop. +it.skip('cannot set to unknown properties', () => { + let _initProto5, _normalPropertyDecs5, _init_normalProperty5; + class BadTestElement extends XElement { + static { + [_init_normalProperty5, _initProto5] = _applyDecs(this, [[_normalPropertyDecs5, 1, "normalProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto5(this), _init_normalProperty5(this)); + get [(_normalPropertyDecs5 = property({ + type: String + }), "normalProperty")]() { + return this.#A; + } + set normalProperty(v) { + this.#A = v; + } + static template(host) { + host.doesNotExist = 'Dromedary'; + return html`
${host.normalProperty}
`; + } + } + customElements.define('bad-test-element-next-2', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Property "BadTestElement.properties.doesNotExist" does not exist.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. In this case, we expect our +// users to be experts and not pull objects which don’t exist (or understand +// that it doesn’t exist if it is returning “undefined”). +it.skip('cannot get unknown properties', () => { + let _initProto6, _normalPropertyDecs6, _init_normalProperty6; + class BadTestElement extends XElement { + static { + [_init_normalProperty6, _initProto6] = _applyDecs(this, [[_normalPropertyDecs6, 1, "normalProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto6(this), _init_normalProperty6(this)); + get [(_normalPropertyDecs6 = property({ + type: String + }), "normalProperty")]() { + return this.#A; + } + set normalProperty(v) { + this.#A = v; + } + static template(host) { + return html`
${host.doesNotExist}
`; + } + } + customElements.define('bad-test-element-next-3', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Property "BadTestElement.properties.doesNotExist" does not exist.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test internal proxy, but it +// now just checks basic, idiomatic JavaScript. +it.skip('cannot set on "internal"', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.internal.normalProperty = 'Dromedary'; + } catch (error) { + const expected = 'Property "TestElement.properties.normalProperty" is publicly available (use normal setter).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. You can of course define a +// new property on an instance like this. This would work even if it was truly +// shadowing an accessor that already exists. +it.skip('cannot "defineProperty" on properties.', () => { + let _initProto7, _normalPropertyDecs7, _init_normalProperty7; + class BadTestElement extends XElement { + static { + [_init_normalProperty7, _initProto7] = _applyDecs(this, [[_normalPropertyDecs7, 1, "normalProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto7(this), _init_normalProperty7(this)); + get [(_normalPropertyDecs7 = property({ + type: String + }), "normalProperty")]() { + return this.#A; + } + set normalProperty(v) { + this.#A = v; + } + static template(host) { + Reflect.defineProperty(host, 'foo', {}); + return html``; + } + } + customElements.define('bad-test-element-next-4', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. You can of course call delete +// on an instance like this — but, this doesn’t break the accessors in any way. +it.skip('cannot "delete" on properties.', () => { + let _initProto8, _normalPropertyDecs8, _init_normalProperty8; + class BadTestElement extends XElement { + static { + [_init_normalProperty8, _initProto8] = _applyDecs(this, [[_normalPropertyDecs8, 1, "normalProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto8(this), _init_normalProperty8(this)); + get [(_normalPropertyDecs8 = property({ + type: String + }), "normalProperty")]() { + return this.#A; + } + set normalProperty(v) { + this.#A = v; + } + static template(host) { + Reflect.deleteProperty(host, 'normalProperty'); + return html``; + } + } + customElements.define('bad-test-element-next-5', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. +it.skip('cannot "getOwnPropertyDescriptor" on properties.', () => { + let _initProto9, _normalPropertyDecs9, _init_normalProperty9; + class BadTestElement extends XElement { + static { + [_init_normalProperty9, _initProto9] = _applyDecs(this, [[_normalPropertyDecs9, 1, "normalProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto9(this), _init_normalProperty9(this)); + get [(_normalPropertyDecs9 = property({ + type: String + }), "normalProperty")]() { + return this.#A; + } + set normalProperty(v) { + this.#A = v; + } + static template(host) { + Reflect.getOwnPropertyDescriptor(host, 'normalProperty'); + return html``; + } + } + customElements.define('bad-test-element-next-6', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. +it.skip('cannot "getPrototypeOf" on properties.', () => { + let _initProto0, _normalPropertyDecs0, _init_normalProperty0; + class BadTestElement extends XElement { + static { + [_init_normalProperty0, _initProto0] = _applyDecs(this, [[_normalPropertyDecs0, 1, "normalProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto0(this), _init_normalProperty0(this)); + get [(_normalPropertyDecs0 = property({ + type: String + }), "normalProperty")]() { + return this.#A; + } + set normalProperty(v) { + this.#A = v; + } + static template(host) { + Reflect.getPrototypeOf(host); + return html``; + } + } + customElements.define('bad-test-element-next-7', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. +it.skip('cannot "isExtensible" on properties.', () => { + let _initProto1, _normalPropertyDecs1, _init_normalProperty1; + class BadTestElement extends XElement { + static { + [_init_normalProperty1, _initProto1] = _applyDecs(this, [[_normalPropertyDecs1, 1, "normalProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto1(this), _init_normalProperty1(this)); + get [(_normalPropertyDecs1 = property({ + type: String + }), "normalProperty")]() { + return this.#A; + } + set normalProperty(v) { + this.#A = v; + } + static template(host) { + Reflect.isExtensible(host); + return html``; + } + } + customElements.define('bad-test-element-next-8', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. +it.skip('cannot "preventExtensions" on properties.', () => { + let _initProto10, _normalPropertyDecs10, _init_normalProperty10; + class BadTestElement extends XElement { + static { + [_init_normalProperty10, _initProto10] = _applyDecs(this, [[_normalPropertyDecs10, 1, "normalProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto10(this), _init_normalProperty10(this)); + get [(_normalPropertyDecs10 = property({ + type: String + }), "normalProperty")]() { + return this.#A; + } + set normalProperty(v) { + this.#A = v; + } + static template(host) { + Reflect.preventExtensions(host); + return html``; + } + } + customElements.define('bad-test-element-next-9', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. +it.skip('cannot "setPrototypeOf" on properties.', () => { + let _initProto11, _normalPropertyDecs11, _init_normalProperty11; + class BadTestElement extends XElement { + static { + [_init_normalProperty11, _initProto11] = _applyDecs(this, [[_normalPropertyDecs11, 1, "normalProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto11(this), _init_normalProperty11(this)); + get [(_normalPropertyDecs11 = property({ + type: String + }), "normalProperty")]() { + return this.#A; + } + set normalProperty(v) { + this.#A = v; + } + static template(host) { + Reflect.setPrototypeOf(host, Array); + return html``; + } + } + customElements.define('bad-test-element-next-10', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["assert","it","XElement","property","html","TestElementNext","_init_normalProperty","_init_objectProperty","_init_camelCaseProperty","_init_numericProperty","_init_nullProperty","_init_undefinedProperty","_init_typelessProperty","_init_typelessPropertyWithCustomAttribute","_init_internalProperty","_get_internalProperty","_set_internalProperty","_initProto","_applyDecs","_normalPropertyDecs","_objectPropertyDecs","_camelCasePropertyDecs","_numericPropertyDecs","_nullPropertyDecs","_undefinedPropertyDecs","_typelessPropertyDecs","_typelessPropertyWithCustomAttributeDecs","_internalPropertyDecs","o","I","v","_","internalProperty","e","A","type","String","initial","Object","Number","default","attribute","normalProperty","B","objectProperty","C","camelCaseProperty","D","numericProperty","E","nullProperty","F","undefinedProperty","G","typelessProperty","H","typelessPropertyWithCustomAttribute","#internalProperty","template","host","customElements","define","el","document","createElement","body","append","shadowRoot","getElementById","textContent","Promise","resolve","expected","actual","constructor","observedAttributes","length","every","includes","removeAttribute","setAttribute","value","_initProto2","_normalPropertyDecs2","_init_normalProperty2","TempTestElement","Reflect","has","Error","passed","message","connectedCallback","error","skip","_initProto3","_normalPropertyDecs3","_init_normalProperty3","ownKeys","array","isNaN","_initProto4","_normalPropertyDecs4","_init_normalProperty4","BadTestElement","_initProto5","_normalPropertyDecs5","_init_normalProperty5","doesNotExist","_initProto6","_normalPropertyDecs6","_init_normalProperty6","internal","_initProto7","_normalPropertyDecs7","_init_normalProperty7","defineProperty","_initProto8","_normalPropertyDecs8","_init_normalProperty8","deleteProperty","_initProto9","_normalPropertyDecs9","_init_normalProperty9","getOwnPropertyDescriptor","_initProto0","_normalPropertyDecs0","_init_normalProperty0","getPrototypeOf","_initProto1","_normalPropertyDecs1","_init_normalProperty1","isExtensible","_initProto10","_normalPropertyDecs10","_init_normalProperty10","preventExtensions","_initProto11","_normalPropertyDecs11","_init_normalProperty11","setPrototypeOf","Array"],"sources":["test-basic-properties.src.js"],"sourcesContent":["import { assert, it } from '@netflix/x-test/x-test.js';\nimport { XElement, property, html } from '../x-element-next.js';\n\nclass TestElementNext extends XElement {\n  @property({ type: String, initial: 'Ferus' })\n  accessor normalProperty;\n\n  @property({ type: Object })\n  accessor objectProperty;\n\n  @property({ type: String, initial: 'Bactrian' })\n  accessor camelCaseProperty;\n\n  @property({ type: Number, default: 10 })\n  accessor numericProperty;\n\n  @property({ type: String, default: null })\n  accessor nullProperty;\n\n  @property({ type: String })\n  accessor undefinedProperty;\n\n  @property({})\n  accessor typelessProperty;\n\n  @property({ attribute: 'custom-attribute-typeless' })\n  accessor typelessPropertyWithCustomAttribute;\n\n  @property({})\n  accessor #internalProperty;\n\n  static template(host) {\n    return html`\n      <div id=\"normal\">${host.normalProperty}</div>\n      <span id=\"camel\">${host.camelCaseProperty}</span>\n      <span id=\"num\">${host.numericProperty}</span>\n      <span id=\"nul\">${host.nullProperty}</span>\n      <span id=\"undef\">${host.undefinedProperty}</span>\n    `;\n  }\n}\ncustomElements.define('test-element-next', TestElementNext);\n\nit('initialization', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  assert(el.shadowRoot.getElementById('normal').textContent === 'Ferus');\n  assert(el.shadowRoot.getElementById('camel').textContent === 'Bactrian');\n  assert(el.shadowRoot.getElementById('num').textContent === '10');\n  assert(el.shadowRoot.getElementById('nul').textContent === '');\n});\n\nit('renders an empty string in place of null value', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  assert(el.shadowRoot.getElementById('nul').textContent === '');\n});\n\nit('renders an empty string in place of undefined value', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  assert(el.shadowRoot.getElementById('undef').textContent === '');\n});\n\nit('property setter updates on next micro tick after connect', async () => {\n  const el = document.createElement('test-element-next');\n  el.camelCaseProperty = 'Nonconforming';\n\n  // Initial render happens synchronously after initial connection.\n  document.body.append(el);\n  assert(el.shadowRoot.getElementById('camel').textContent === 'Nonconforming');\n\n  // Updates are debounced on a microtask, so they are not immediately seen.\n  el.camelCaseProperty = 'Dromedary';\n  assert(el.shadowRoot.getElementById('camel').textContent === 'Nonconforming');\n\n  // After the microtask runs, the update is handled.\n  await Promise.resolve();\n  assert(el.shadowRoot.getElementById('camel').textContent === 'Dromedary');\n});\n\nit('property setter renders blank value', async () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  el.camelCaseProperty = '';\n\n  // We must await a microtask for the update to take place.\n  await Promise.resolve();\n  assert(el.shadowRoot.getElementById('camel').textContent === '');\n  el.camelCaseProperty = 'Bactrian';\n\n  // We must await a microtask for the update to take place.\n  await Promise.resolve();\n  assert(el.shadowRoot.getElementById('camel').textContent === 'Bactrian');\n});\n\nit('observes all dash-cased versions of public, typeless, serializable, and declared properties', () => {\n  const el = document.createElement('test-element-next');\n  const expected = [\n    'normal-property',\n    'camel-case-property',\n    'numeric-property',\n    'null-property',\n    'undefined-property',\n    'typeless-property',\n    'custom-attribute-typeless',\n  ];\n  const actual = el.constructor.observedAttributes;\n  assert(expected.length === actual.length);\n  assert(expected.every(attribute => actual.includes(attribute)));\n});\n\nit('removeAttribute renders blank', async () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  el.removeAttribute('camel-case-property');\n\n  // We must await a microtask for the update to take place.\n  await Promise.resolve();\n  // Note, in general, changing non-reflected properties via attributes can\n  // be problematic. For example, attributeChangedCallback is not fired if the\n  // attribute does not change.\n  assert(el.shadowRoot.getElementById('camel').textContent !== '');\n  el.setAttribute('camel-case-property', 'foo');\n  el.removeAttribute('camel-case-property');\n\n  // We must await a microtask for the update to take place.\n  await Promise.resolve();\n  assert(el.shadowRoot.getElementById('camel').textContent === '');\n});\n\nit('setAttribute renders the new value', async () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  el.setAttribute('camel-case-property', 'Racing Camel');\n\n  // We must await a microtask for the update to take place.\n  await Promise.resolve();\n  assert(el.shadowRoot.getElementById('camel').textContent === 'Racing Camel');\n});\n\nit('coerces attributes to the specified type', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  el.setAttribute('numeric-property', '-99');\n  assert(el.numericProperty === -99);\n});\n\nit('allows properties without types', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  for (const value of [{}, 'foo', '5', [], 2]) {\n    el.typelessProperty = value;\n    assert(el.typelessProperty === value);\n  }\n});\n\nit('syncs attributes to properties without types', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  const value = '123';\n  el.setAttribute('typeless-property', value);\n  assert(el.typelessProperty === value);\n});\n\nit('initializes from attributes on connect', () => {\n  const el = document.createElement('test-element-next');\n  el.setAttribute('camel-case-property', 'Dromedary');\n  document.body.append(el);\n  assert(el.camelCaseProperty === 'Dromedary');\n});\n\n// TODO: #346: We can likely delete. It used to test properties proxy, but it\n//  now just checks basic, idiomatic JavaScript.\nit('can use \"has\" api or \"in\" operator.', () => {\n  class TempTestElement extends XElement {\n    @property({ type: String })\n    accessor normalProperty;\n\n    static template(host) {\n      if (!('normalProperty' in host) || Reflect.has(host, 'normalProperty') === false) {\n        throw new Error('The \"has\" trap does not work.');\n      }\n      return html``;\n    }\n  }\n  customElements.define('temp-test-element-next-1', TempTestElement);\n  const el = new TempTestElement();\n  let passed = false;\n  let message;\n  try {\n    el.connectedCallback();\n    passed = true;\n  } catch (error) {\n    message = error.message;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test properties proxy, but it\n//  now just checks basic, idiomatic JavaScript. In this case, ownKeys doesn’t\n//  work because properties are simply on the `host.prototype`.\nit.skip('can use \"ownKeys\" api.', () => {\n  class TempTestElement extends XElement {\n    @property({ type: String })\n    accessor normalProperty;\n\n    static template(host) {\n      const ownKeys = Reflect.ownKeys(host);\n      if (ownKeys.length !== 1 || ownKeys[0] !== 'normalProperty') {\n        throw new Error('The \"ownKeys\" trap does not work.');\n      }\n      return html``;\n    }\n  }\n  customElements.define('temp-test-element-next-2', TempTestElement);\n  const el = new TempTestElement();\n  let passed = false;\n  let message;\n  try {\n    el.connectedCallback();\n    passed = true;\n  } catch (error) {\n    message = error.message;\n  }\n  assert(passed, message);\n});\n\nit('can be read', async () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  assert(el.normalProperty === 'Ferus', 'property was read');\n  el.normalProperty = 'Dromedary';\n  assert(el.normalProperty === 'Dromedary', 'property was written to');\n\n  // We must await a microtask for the update to take place.\n  await Promise.resolve();\n  assert(el.shadowRoot.getElementById('normal').textContent === 'Dromedary');\n});\n\nit('inheritance is considered in type checking', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  const array = [];\n  el.objectProperty = array;\n  assert(el.objectProperty === array, 'property was set');\n});\n\nit('numeric properties deserialize \"\" (empty) to \"NaN\"', () => {\n  const el = document.createElement('test-element-next');\n  el.setAttribute('numeric-property', '0');\n  document.body.append(el);\n  assert(el.numericProperty === 0, '\"0\" was coerced to 0');\n  el.setAttribute('numeric-property', '');\n  assert(Number.isNaN(el.numericProperty), '\"\" was coerced to NaN');\n  el.setAttribute('numeric-property', ' ');\n  assert(Number.isNaN(el.numericProperty), '\" \" was coerced to NaN');\n  el.setAttribute('numeric-property', '      ');\n  assert(Number.isNaN(el.numericProperty), '\"      \" was coerced to NaN');\n});\n\n// TODO: #346: We can likely delete. It used to test properties proxy, but it\n//  now just checks basic, idiomatic JavaScript. In this case, we expect our\n//  users to be experts and not update properties in the render loop.\nit.skip('cannot set to known properties', () => {\n  class BadTestElement extends XElement {\n    @property({ type: String })\n    accessor normalProperty;\n\n    static template(host) {\n      host.normalProperty = 'Dromedary';\n      return html`<div>${host.normalProperty}</div>`;\n    }\n  }\n  customElements.define('bad-test-element-next-1', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Cannot set \"BadTestElement.properties.normalProperty\" via \"properties\".';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test properties proxy, but it\n//  now just checks basic, idiomatic JavaScript. In this case, we expect our\n//  users to be experts and not update properties in the render loop.\nit.skip('cannot set to unknown properties', () => {\n  class BadTestElement extends XElement {\n    @property({ type: String })\n    accessor normalProperty;\n\n    static template(host) {\n      host.doesNotExist = 'Dromedary';\n      return html`<div>${host.normalProperty}</div>`;\n    }\n  }\n  customElements.define('bad-test-element-next-2', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Property \"BadTestElement.properties.doesNotExist\" does not exist.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test properties proxy, but it\n//  now just checks basic, idiomatic JavaScript. In this case, we expect our\n//  users to be experts and not pull objects which don’t exist (or understand\n//  that it doesn’t exist if it is returning “undefined”).\nit.skip('cannot get unknown properties', () => {\n  class BadTestElement extends XElement {\n    @property({ type: String })\n    accessor normalProperty;\n\n    static template(host) {\n      return html`<div>${host.doesNotExist}</div>`;\n    }\n  }\n  customElements.define('bad-test-element-next-3', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Property \"BadTestElement.properties.doesNotExist\" does not exist.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test internal proxy, but it\n//  now just checks basic, idiomatic JavaScript.\nit.skip('cannot set on \"internal\"', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.internal.normalProperty = 'Dromedary';\n  } catch (error) {\n    const expected = 'Property \"TestElement.properties.normalProperty\" is publicly available (use normal setter).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test properties proxy, but it\n//  now just checks basic, idiomatic JavaScript. You can of course define a\n//  new property on an instance like this. This would work even if it was truly\n//  shadowing an accessor that already exists.\nit.skip('cannot \"defineProperty\" on properties.', () => {\n  class BadTestElement extends XElement {\n    @property({ type: String })\n    accessor normalProperty;\n\n    static template(host) {\n      Reflect.defineProperty(host, 'foo', {});\n      return html``;\n    }\n  }\n  customElements.define('bad-test-element-next-4', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Invalid use of properties proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test properties proxy, but it\n//  now just checks basic, idiomatic JavaScript. You can of course call delete\n//  on an instance like this — but, this doesn’t break the accessors in any way.\nit.skip('cannot \"delete\" on properties.', () => {\n  class BadTestElement extends XElement {\n    @property({ type: String })\n    accessor normalProperty;\n\n    static template(host) {\n      Reflect.deleteProperty(host, 'normalProperty');\n      return html``;\n    }\n  }\n  customElements.define('bad-test-element-next-5', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Invalid use of properties proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test properties proxy, but it\n//  now just checks basic, idiomatic JavaScript.\nit.skip('cannot \"getOwnPropertyDescriptor\" on properties.', () => {\n  class BadTestElement extends XElement {\n    @property({ type: String })\n    accessor normalProperty;\n\n    static template(host) {\n      Reflect.getOwnPropertyDescriptor(host, 'normalProperty');\n      return html``;\n    }\n  }\n  customElements.define('bad-test-element-next-6', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Invalid use of properties proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test properties proxy, but it\n//  now just checks basic, idiomatic JavaScript.\nit.skip('cannot \"getPrototypeOf\" on properties.', () => {\n  class BadTestElement extends XElement {\n    @property({ type: String })\n    accessor normalProperty;\n\n    static template(host) {\n      Reflect.getPrototypeOf(host);\n      return html``;\n    }\n  }\n  customElements.define('bad-test-element-next-7', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Invalid use of properties proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test properties proxy, but it\n//  now just checks basic, idiomatic JavaScript.\nit.skip('cannot \"isExtensible\" on properties.', () => {\n  class BadTestElement extends XElement {\n    @property({ type: String })\n    accessor normalProperty;\n\n    static template(host) {\n      Reflect.isExtensible(host);\n      return html``;\n    }\n  }\n  customElements.define('bad-test-element-next-8', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Invalid use of properties proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test properties proxy, but it\n//  now just checks basic, idiomatic JavaScript.\nit.skip('cannot \"preventExtensions\" on properties.', () => {\n  class BadTestElement extends XElement {\n    @property({ type: String })\n    accessor normalProperty;\n\n    static template(host) {\n      Reflect.preventExtensions(host);\n      return html``;\n    }\n  }\n  customElements.define('bad-test-element-next-9', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Invalid use of properties proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test properties proxy, but it\n//  now just checks basic, idiomatic JavaScript.\nit.skip('cannot \"setPrototypeOf\" on properties.', () => {\n  class BadTestElement extends XElement {\n    @property({ type: String })\n    accessor normalProperty;\n\n    static template(host) {\n      Reflect.setPrototypeOf(host, Array);\n      return html``;\n    }\n  }\n  customElements.define('bad-test-element-next-10', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Invalid use of properties proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/test-next/test-basic-properties.src.js b/test-next/test-basic-properties.src.js new file mode 100644 index 0000000..a435526 --- /dev/null +++ b/test-next/test-basic-properties.src.js @@ -0,0 +1,543 @@ +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; + +class TestElementNext extends XElement { + @property({ type: String, initial: 'Ferus' }) + accessor normalProperty; + + @property({ type: Object }) + accessor objectProperty; + + @property({ type: String, initial: 'Bactrian' }) + accessor camelCaseProperty; + + @property({ type: Number, default: 10 }) + accessor numericProperty; + + @property({ type: String, default: null }) + accessor nullProperty; + + @property({ type: String }) + accessor undefinedProperty; + + @property({}) + accessor typelessProperty; + + @property({ attribute: 'custom-attribute-typeless' }) + accessor typelessPropertyWithCustomAttribute; + + @property({}) + accessor #internalProperty; + + static template(host) { + return html` +
${host.normalProperty}
+ ${host.camelCaseProperty} + ${host.numericProperty} + ${host.nullProperty} + ${host.undefinedProperty} + `; + } +} +customElements.define('test-element-next', TestElementNext); + +it('initialization', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.shadowRoot.getElementById('normal').textContent === 'Ferus'); + assert(el.shadowRoot.getElementById('camel').textContent === 'Bactrian'); + assert(el.shadowRoot.getElementById('num').textContent === '10'); + assert(el.shadowRoot.getElementById('nul').textContent === ''); +}); + +it('renders an empty string in place of null value', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.shadowRoot.getElementById('nul').textContent === ''); +}); + +it('renders an empty string in place of undefined value', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.shadowRoot.getElementById('undef').textContent === ''); +}); + +it('property setter updates on next micro tick after connect', async () => { + const el = document.createElement('test-element-next'); + el.camelCaseProperty = 'Nonconforming'; + + // Initial render happens synchronously after initial connection. + document.body.append(el); + assert(el.shadowRoot.getElementById('camel').textContent === 'Nonconforming'); + + // Updates are debounced on a microtask, so they are not immediately seen. + el.camelCaseProperty = 'Dromedary'; + assert(el.shadowRoot.getElementById('camel').textContent === 'Nonconforming'); + + // After the microtask runs, the update is handled. + await Promise.resolve(); + assert(el.shadowRoot.getElementById('camel').textContent === 'Dromedary'); +}); + +it('property setter renders blank value', async () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.camelCaseProperty = ''; + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.shadowRoot.getElementById('camel').textContent === ''); + el.camelCaseProperty = 'Bactrian'; + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.shadowRoot.getElementById('camel').textContent === 'Bactrian'); +}); + +it('observes all dash-cased versions of public, typeless, serializable, and declared properties', () => { + const el = document.createElement('test-element-next'); + const expected = [ + 'normal-property', + 'camel-case-property', + 'numeric-property', + 'null-property', + 'undefined-property', + 'typeless-property', + 'custom-attribute-typeless', + ]; + const actual = el.constructor.observedAttributes; + assert(expected.length === actual.length); + assert(expected.every(attribute => actual.includes(attribute))); +}); + +it('removeAttribute renders blank', async () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.removeAttribute('camel-case-property'); + + // We must await a microtask for the update to take place. + await Promise.resolve(); + // Note, in general, changing non-reflected properties via attributes can + // be problematic. For example, attributeChangedCallback is not fired if the + // attribute does not change. + assert(el.shadowRoot.getElementById('camel').textContent !== ''); + el.setAttribute('camel-case-property', 'foo'); + el.removeAttribute('camel-case-property'); + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.shadowRoot.getElementById('camel').textContent === ''); +}); + +it('setAttribute renders the new value', async () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.setAttribute('camel-case-property', 'Racing Camel'); + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.shadowRoot.getElementById('camel').textContent === 'Racing Camel'); +}); + +it('coerces attributes to the specified type', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.setAttribute('numeric-property', '-99'); + assert(el.numericProperty === -99); +}); + +it('allows properties without types', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + for (const value of [{}, 'foo', '5', [], 2]) { + el.typelessProperty = value; + assert(el.typelessProperty === value); + } +}); + +it('syncs attributes to properties without types', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + const value = '123'; + el.setAttribute('typeless-property', value); + assert(el.typelessProperty === value); +}); + +it('initializes from attributes on connect', () => { + const el = document.createElement('test-element-next'); + el.setAttribute('camel-case-property', 'Dromedary'); + document.body.append(el); + assert(el.camelCaseProperty === 'Dromedary'); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. +it('can use "has" api or "in" operator.', () => { + class TempTestElement extends XElement { + @property({ type: String }) + accessor normalProperty; + + static template(host) { + if (!('normalProperty' in host) || Reflect.has(host, 'normalProperty') === false) { + throw new Error('The "has" trap does not work.'); + } + return html``; + } + } + customElements.define('temp-test-element-next-1', TempTestElement); + const el = new TempTestElement(); + let passed = false; + let message; + try { + el.connectedCallback(); + passed = true; + } catch (error) { + message = error.message; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. In this case, ownKeys doesn’t +// work because properties are simply on the `host.prototype`. +it.skip('can use "ownKeys" api.', () => { + class TempTestElement extends XElement { + @property({ type: String }) + accessor normalProperty; + + static template(host) { + const ownKeys = Reflect.ownKeys(host); + if (ownKeys.length !== 1 || ownKeys[0] !== 'normalProperty') { + throw new Error('The "ownKeys" trap does not work.'); + } + return html``; + } + } + customElements.define('temp-test-element-next-2', TempTestElement); + const el = new TempTestElement(); + let passed = false; + let message; + try { + el.connectedCallback(); + passed = true; + } catch (error) { + message = error.message; + } + assert(passed, message); +}); + +it('can be read', async () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.normalProperty === 'Ferus', 'property was read'); + el.normalProperty = 'Dromedary'; + assert(el.normalProperty === 'Dromedary', 'property was written to'); + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.shadowRoot.getElementById('normal').textContent === 'Dromedary'); +}); + +it('inheritance is considered in type checking', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + const array = []; + el.objectProperty = array; + assert(el.objectProperty === array, 'property was set'); +}); + +it('numeric properties deserialize "" (empty) to "NaN"', () => { + const el = document.createElement('test-element-next'); + el.setAttribute('numeric-property', '0'); + document.body.append(el); + assert(el.numericProperty === 0, '"0" was coerced to 0'); + el.setAttribute('numeric-property', ''); + assert(Number.isNaN(el.numericProperty), '"" was coerced to NaN'); + el.setAttribute('numeric-property', ' '); + assert(Number.isNaN(el.numericProperty), '" " was coerced to NaN'); + el.setAttribute('numeric-property', ' '); + assert(Number.isNaN(el.numericProperty), '" " was coerced to NaN'); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. In this case, we expect our +// users to be experts and not update properties in the render loop. +it.skip('cannot set to known properties', () => { + class BadTestElement extends XElement { + @property({ type: String }) + accessor normalProperty; + + static template(host) { + host.normalProperty = 'Dromedary'; + return html`
${host.normalProperty}
`; + } + } + customElements.define('bad-test-element-next-1', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Cannot set "BadTestElement.properties.normalProperty" via "properties".'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. In this case, we expect our +// users to be experts and not update properties in the render loop. +it.skip('cannot set to unknown properties', () => { + class BadTestElement extends XElement { + @property({ type: String }) + accessor normalProperty; + + static template(host) { + host.doesNotExist = 'Dromedary'; + return html`
${host.normalProperty}
`; + } + } + customElements.define('bad-test-element-next-2', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Property "BadTestElement.properties.doesNotExist" does not exist.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. In this case, we expect our +// users to be experts and not pull objects which don’t exist (or understand +// that it doesn’t exist if it is returning “undefined”). +it.skip('cannot get unknown properties', () => { + class BadTestElement extends XElement { + @property({ type: String }) + accessor normalProperty; + + static template(host) { + return html`
${host.doesNotExist}
`; + } + } + customElements.define('bad-test-element-next-3', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Property "BadTestElement.properties.doesNotExist" does not exist.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test internal proxy, but it +// now just checks basic, idiomatic JavaScript. +it.skip('cannot set on "internal"', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.internal.normalProperty = 'Dromedary'; + } catch (error) { + const expected = 'Property "TestElement.properties.normalProperty" is publicly available (use normal setter).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. You can of course define a +// new property on an instance like this. This would work even if it was truly +// shadowing an accessor that already exists. +it.skip('cannot "defineProperty" on properties.', () => { + class BadTestElement extends XElement { + @property({ type: String }) + accessor normalProperty; + + static template(host) { + Reflect.defineProperty(host, 'foo', {}); + return html``; + } + } + customElements.define('bad-test-element-next-4', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. You can of course call delete +// on an instance like this — but, this doesn’t break the accessors in any way. +it.skip('cannot "delete" on properties.', () => { + class BadTestElement extends XElement { + @property({ type: String }) + accessor normalProperty; + + static template(host) { + Reflect.deleteProperty(host, 'normalProperty'); + return html``; + } + } + customElements.define('bad-test-element-next-5', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. +it.skip('cannot "getOwnPropertyDescriptor" on properties.', () => { + class BadTestElement extends XElement { + @property({ type: String }) + accessor normalProperty; + + static template(host) { + Reflect.getOwnPropertyDescriptor(host, 'normalProperty'); + return html``; + } + } + customElements.define('bad-test-element-next-6', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. +it.skip('cannot "getPrototypeOf" on properties.', () => { + class BadTestElement extends XElement { + @property({ type: String }) + accessor normalProperty; + + static template(host) { + Reflect.getPrototypeOf(host); + return html``; + } + } + customElements.define('bad-test-element-next-7', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. +it.skip('cannot "isExtensible" on properties.', () => { + class BadTestElement extends XElement { + @property({ type: String }) + accessor normalProperty; + + static template(host) { + Reflect.isExtensible(host); + return html``; + } + } + customElements.define('bad-test-element-next-8', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. +it.skip('cannot "preventExtensions" on properties.', () => { + class BadTestElement extends XElement { + @property({ type: String }) + accessor normalProperty; + + static template(host) { + Reflect.preventExtensions(host); + return html``; + } + } + customElements.define('bad-test-element-next-9', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy, but it +// now just checks basic, idiomatic JavaScript. +it.skip('cannot "setPrototypeOf" on properties.', () => { + class BadTestElement extends XElement { + @property({ type: String }) + accessor normalProperty; + + static template(host) { + Reflect.setPrototypeOf(host, Array); + return html``; + } + } + customElements.define('bad-test-element-next-10', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid use of properties proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); diff --git a/test-next/test-computed-properties.html b/test-next/test-computed-properties.html new file mode 100644 index 0000000..e94a85b --- /dev/null +++ b/test-next/test-computed-properties.html @@ -0,0 +1,18 @@ + + + + + + + + +

Test Computed Properties

+ + + diff --git a/test-next/test-computed-properties.js b/test-next/test-computed-properties.js new file mode 100644 index 0000000..dd9e5ac --- /dev/null +++ b/test-next/test-computed-properties.js @@ -0,0 +1,382 @@ +let _initProto, _cDecs, _init_c, _get_c, _set_c, _cDecs2, _init_c2, _aDecs, _init_a, _bDecs, _init_b, _negativeDecs, _init_negative, _underlineDecs, _init_underline, _italicDecs, _init_italic, _yDecs, _init_y, _zDecs, _init_z, _todayDecs, _init_today, _tomorrowDecs, _init_tomorrow, _countTriggerDecs, _init_countTrigger, _countDecs, _init_count; +function _applyDecs(e, t, r, n, o, a) { function i(e, t, r) { return function (n, o) { return r && r(n), e[t].call(n, o); }; } function c(e, t) { for (var r = 0; r < e.length; r++) e[r].call(t); return t; } function s(e, t, r, n) { if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); return e; } function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { function m(e) { if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); } var y, v = t[0], g = t[3], b = !u; if (!b) { r || Array.isArray(v) || (v = [v]); var w = {}, S = [], A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; f ? (p || d ? w = { get: _setFunctionName(function () { return g(this); }, n, "get"), set: function (e) { t[4](this, e); } } : w[A] = g, p || _setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); } for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { var D = v[j], E = r ? v[j - 1] : void 0, I = {}, O = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: n, metadata: a, addInitializer: function (e, t) { if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); s(t, "An initializer", "be", !0), c.push(t); }.bind(null, I) }; try { if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { var k, F; O.static = l, O.private = f, f ? 2 === o ? k = function (e) { return m(e), w.value; } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function (e) { return e[n]; }, (o < 2 || 4 === o) && (F = function (e, t) { e[n] = t; })); var N = O.access = { has: f ? h.bind() : function (e) { return n in e; } }; if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { get: w.get, set: w.set } : w[A], O), d) { if ("object" == typeof P && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); } } finally { I.v = !0; } } return (p || d) && u.push(function (e, t) { for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); return t; }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; } function u(e, t) { return Object.defineProperty(e, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: !0, enumerable: !0, value: t }); } if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol.for("Symbol.metadata")]; var f = Object.create(null == l ? null : l), p = function (e, t, r, n) { var o, a, i = [], s = function (t) { return _checkInRHS(t) === e; }, u = new Map(); function l(e) { e && i.push(c.bind(null, e)); } for (var f = 0; f < t.length; f++) { var p = t[f]; if (Array.isArray(p)) { var d = p[1], h = p[2], m = p.length > 3, y = 16 & d, v = !!(8 & d), g = 0 == (d &= 7), b = h + "/" + v; if (!g && !m) { var w = u.get(b); if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); u.set(b, !(d > 2) || d); } applyDec(v ? e : e.prototype, p, y, m ? "#" + h : _toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); } } return l(o), l(a), i; }(e, t, o, f); return r.length || u(e, f), { e: p, get c() { var t = []; return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; } }; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; } +function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; } +import { it, assert } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; +let _count = 0; +class TestElement extends XElement { + static { + [_init_c, _get_c, _set_c, _init_c2, _init_a, _init_b, _init_negative, _init_underline, _init_italic, _init_y, _init_z, _init_today, _init_tomorrow, _init_countTrigger, _init_count, _initProto] = _applyDecs(this, [[_cDecs, 1, "c", o => o.#A, (o, v) => o.#A = v], [_cDecs2, 1, "c"], [_aDecs, 1, "a"], [_bDecs, 1, "b"], [_negativeDecs, 1, "negative"], [_underlineDecs, 1, "underline"], [_italicDecs, 1, "italic"], [_yDecs, 1, "y"], [_zDecs, 1, "z"], [_todayDecs, 1, "today"], [_tomorrowDecs, 1, "tomorrow"], [_countTriggerDecs, 1, "countTrigger"], [_countDecs, 1, "count"]], [], 0, _ => #c in _, XElement).e; + } + static get [(_cDecs = property({ + type: Number, + input: ['a', 'b'], + compute: (a, b) => TestElement.#computeC(a, b) + }), _cDecs2 = property({ + type: Number, + input: ['#c'], + compute: c => c + }), _aDecs = property({ + type: Number + }), _bDecs = property({ + type: Number + }), _negativeDecs = property({ + type: Boolean, + input: ['#c'], + compute: c => c < 0, + reflect: true + }), _underlineDecs = property({ + type: Boolean, + input: ['negative'], + compute: negative => TestElement.#computeUnderline(negative), + reflect: true + }), _italicDecs = property({ + type: Boolean, + reflect: true + }), _yDecs = property({ + type: Boolean + }), _zDecs = property({ + type: Boolean, + input: ['y'], + compute: y => TestElement.#computeZ(y) + }), _todayDecs = property({ + type: Date + }), _tomorrowDecs = property({ + type: Date, + input: ['today'], + compute: today => TestElement.#computeTomorrow(today) + }), _countTriggerDecs = property({}), _countDecs = property({ + type: Number, + input: ['countTrigger'], + compute: () => TestElement.#computeCount() + }), "styles")]() { + const styleSheet = new CSSStyleSheet(); + styleSheet.replaceSync(`\ + #calculation { + background-color: lightgreen; + padding: 10px; + } + + :host([negative]) #calculation { + background-color: lightcoral; + } + + :host([underline]) #calculation { + text-decoration: underline; + } + + :host([italic]) #calculation { + font-style: italic; + } + `); + return [styleSheet]; + } + #A = (_initProto(this), _init_c(this)); + set #c(v) { + _set_c(this, v); + } + get #c() { + return _get_c(this); + } + #B = _init_c2(this); + get c() { + return this.#B; + } + set c(v) { + this.#B = v; + } + #C = _init_a(this); + get a() { + return this.#C; + } + set a(v) { + this.#C = v; + } + #D = _init_b(this); + get b() { + return this.#D; + } + set b(v) { + this.#D = v; + } + #E = _init_negative(this); + get negative() { + return this.#E; + } + set negative(v) { + this.#E = v; + } + #F = _init_underline(this); + get underline() { + return this.#F; + } + set underline(v) { + this.#F = v; + } + #G = _init_italic(this); + get italic() { + return this.#G; + } + set italic(v) { + this.#G = v; + } + #H = _init_y(this); + get y() { + return this.#H; + } + set y(v) { + this.#H = v; + } + #I = _init_z(this); + get z() { + return this.#I; + } + set z(v) { + this.#I = v; + } + #J = _init_today(this); + get today() { + return this.#J; + } + set today(v) { + this.#J = v; + } + #K = _init_tomorrow(this); + get tomorrow() { + return this.#K; + } + set tomorrow(v) { + this.#K = v; + } + #L = _init_countTrigger(this); + get countTrigger() { + return this.#L; + } + set countTrigger(v) { + this.#L = v; + } + #M = _init_count(this); + get count() { + return this.#M; + } + set count(v) { + this.#M = v; + } + static #computeC(a, b) { + return a + b; + } + static #computeCount() { + // This doesn't use an observer to prevent a coupled test. + return ++_count; + } + static #computeUnderline(negative) { + return !!negative; + } + static #computeZ(y) { + return y; + } + static #computeTomorrow(today) { + if (today) { + return today.valueOf() + 1000 * 60 * 60 * 24; + } + } + static template(host) { + return html`${host.a} + ${host.b} = ${host.#c}`; + } +} +customElements.define('test-element-next', TestElement); +it('initializes as expected', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.a === undefined); + assert(el.b === undefined); + assert(el.y === undefined); + assert(el.z === undefined); + assert(el.countTrigger === undefined); + assert(Number.isNaN(el.c)); + assert(el.negative === false); + assert(el.underline === false); +}); +it('properties are recomputed when dependencies change (a, b)', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.a = 1; + el.b = -2; + assert(el.a === 1); + assert(el.b === -2); + assert(el.c === -1); + assert(el.negative === true); + assert(el.underline === true); +}); +it('properties are recomputed when dependencies change (y)', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.y = true; + assert(el.y === true); + assert(el.z === true); + el.y = false; + assert(el.y === false); + assert(el.z === false); +}); +it('computed properties can be reflected', async () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.a = -1; + el.b = 0; + assert(el.c === -1); + assert(el.negative === true); + assert(el.underline === true); + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.hasAttribute('negative')); + assert(el.hasAttribute('underline')); +}); +it('skips resolution when dependencies are the same', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let count = el.count; + el.countTrigger = 'foo'; + assert(el.count === ++count); + el.countTrigger = 'foo'; + el.countTrigger = 'foo'; + el.countTrigger = 'foo'; + el.countTrigger = 'foo'; + assert(el.count === count); + el.countTrigger = 'bar'; + assert(el.count === ++count); +}); +it('lazily computes', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let count = el.count; + el.countTrigger = 'foo'; + assert(el.count === ++count); + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + assert(el.count === count); + el.countTrigger = 'bar'; + assert(el.count === ++count); +}); +it('does correct NaN checking', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let count = el.count; + el.countTrigger = NaN; + assert(el.count === ++count); + el.countTrigger = NaN; + assert(el.count === count); +}); +it('resets compute validity on initialization to catch upgrade edge cases with computed properties', () => { + const el = document.createElement('test-element-next'); + el.setAttribute('a', '1'); + el.setAttribute('b', '2'); + assert(el.a === undefined); + assert(el.b === undefined); + assert(el.c === undefined); + document.body.append(el); + assert(el.a === 1); + assert(el.b === 2); + assert(el.c === 3); +}); +it('cannot be written to from host', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.count = 0; + } catch (error) { + const expected = 'Property "TestElement.prototype.count" is computed (computed properties are read-only).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('cannot set to known properties', () => { + let _initProto2, _computedPropertyDecs, _init_computedProperty; + class BadTestElement extends XElement { + static { + [_init_computedProperty, _initProto2] = _applyDecs(this, [[_computedPropertyDecs, 1, "computedProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto2(this), _init_computedProperty(this)); + get [(_computedPropertyDecs = property({ + type: String, + input: [], + compute: () => {} + }), "computedProperty")]() { + return this.#A; + } + set computedProperty(v) { + this.#A = v; + } + static template(host) { + host.computedProperty = 'Dromedary'; + return html`
${host.computedProperty}
`; + } + } + customElements.define('bad-test-element-next-1', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Property "BadTestElement.prototype.computedProperty" is computed (computed properties are read-only).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('cannot compute a bad value', () => { + let _initProto3, _computedPropertyDecs2, _init_computedProperty2; + class BadTestElement extends XElement { + static { + [_init_computedProperty2, _initProto3] = _applyDecs(this, [[_computedPropertyDecs2, 1, "computedProperty"]], [], 0, void 0, XElement).e; + } + #A = (_initProto3(this), _init_computedProperty2(this)); + get [(_computedPropertyDecs2 = property({ + type: String, + input: [], + compute: () => 0 + }), "computedProperty")]() { + return this.#A; + } + set computedProperty(v) { + this.#A = v; + } + static template(host) { + return html`${host.computedProperty}`; + } + } + customElements.define('bad-test-element-next-2', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Unexpected value for "BadTestElement.prototype.computedProperty" (expected String, got Number).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["it","assert","XElement","property","html","_count","TestElement","_init_c","_get_c","_set_c","_init_c2","_init_a","_init_b","_init_negative","_init_underline","_init_italic","_init_y","_init_z","_init_today","_init_tomorrow","_init_countTrigger","_init_count","_initProto","_applyDecs","_cDecs","o","A","v","_cDecs2","_aDecs","_bDecs","_negativeDecs","_underlineDecs","_italicDecs","_yDecs","_zDecs","_todayDecs","_tomorrowDecs","_countTriggerDecs","_countDecs","_","c","e","type","Number","input","compute","a","b","computeC","Boolean","reflect","negative","computeUnderline","y","computeZ","Date","today","computeTomorrow","computeCount","styleSheet","CSSStyleSheet","replaceSync","#c","B","C","D","E","F","underline","G","italic","H","I","z","J","K","tomorrow","L","countTrigger","M","count","#computeC","#computeCount","#computeUnderline","#computeZ","#computeTomorrow","valueOf","template","host","customElements","define","el","document","createElement","body","append","undefined","isNaN","Promise","resolve","hasAttribute","NaN","setAttribute","passed","message","error","expected","_initProto2","_computedPropertyDecs","_init_computedProperty","BadTestElement","String","computedProperty","connectedCallback","_initProto3","_computedPropertyDecs2","_init_computedProperty2"],"sources":["test-computed-properties.src.js"],"sourcesContent":["import { it, assert } from '@netflix/x-test/x-test.js';\nimport { XElement, property, html } from '../x-element-next.js';\n\nlet _count = 0;\n\nclass TestElement extends XElement {\n  static get styles() {\n    const styleSheet = new CSSStyleSheet();\n    styleSheet.replaceSync(`\\\n      #calculation {\n        background-color: lightgreen;\n        padding: 10px;\n      }\n\n      :host([negative]) #calculation {\n        background-color: lightcoral;\n      }\n\n      :host([underline]) #calculation {\n        text-decoration: underline;\n      }\n\n      :host([italic]) #calculation {\n        font-style: italic;\n      }\n    `);\n    return [styleSheet];\n  }\n\n  @property({\n    type: Number,\n    input: ['a', 'b'],\n    compute: (a, b) => TestElement.#computeC(a, b),\n  })\n  accessor #c;\n\n  @property({\n    type: Number,\n    input: ['#c'],\n    compute: (c) => c,\n  })\n  accessor c;\n\n  @property({ type: Number })\n  accessor a;\n\n  @property({ type: Number })\n  accessor b;\n\n  @property({\n    type: Boolean,\n    input: ['#c'],\n    compute: c => c < 0,\n    reflect: true,\n  })\n  accessor negative;\n\n  @property({\n    type: Boolean,\n    input: ['negative'],\n    compute: (negative) => TestElement.#computeUnderline(negative),\n    reflect: true,\n  })\n  accessor underline;\n\n  @property({\n    type: Boolean,\n    reflect: true,\n  })\n  accessor italic;\n\n  @property({ type: Boolean })\n  accessor y;\n\n  @property({\n    type: Boolean,\n    input: ['y'],\n    compute: (y) => TestElement.#computeZ(y),\n  })\n  accessor z;\n\n  @property({ type: Date })\n  accessor today;\n\n  @property({\n    type: Date,\n    input: ['today'],\n    compute: (today) => TestElement.#computeTomorrow(today),\n  })\n  accessor tomorrow;\n\n  @property({})\n  accessor countTrigger;\n\n  @property({\n    type: Number,\n    input: ['countTrigger'],\n    compute: () => TestElement.#computeCount(),\n  })\n  accessor count;\n\n  static #computeC(a, b) {\n    return a + b;\n  }\n\n  static #computeCount() {\n    // This doesn't use an observer to prevent a coupled test.\n    return ++_count;\n  }\n\n  static #computeUnderline(negative) {\n    return !!negative;\n  }\n\n  static #computeZ(y) {\n    return y;\n  }\n\n  static #computeTomorrow(today) {\n    if (today) {\n      return today.valueOf() + 1000 * 60 * 60 * 24;\n    }\n  }\n\n  static template(host) {\n    return html`<span id=\"calculation\">${host.a} + ${host.b} = ${host.#c}</span>`;\n  }\n}\ncustomElements.define('test-element-next', TestElement);\n\nit('initializes as expected', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  assert(el.a === undefined);\n  assert(el.b === undefined);\n  assert(el.y === undefined);\n  assert(el.z === undefined);\n  assert(el.countTrigger === undefined);\n  assert(Number.isNaN(el.c));\n  assert(el.negative === false);\n  assert(el.underline === false);\n});\n\nit('properties are recomputed when dependencies change (a, b)', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  el.a = 1;\n  el.b = -2;\n  assert(el.a === 1);\n  assert(el.b === -2);\n  assert(el.c === -1);\n  assert(el.negative === true);\n  assert(el.underline === true);\n});\n\nit('properties are recomputed when dependencies change (y)', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  el.y = true;\n  assert(el.y === true);\n  assert(el.z === true);\n  el.y = false;\n  assert(el.y === false);\n  assert(el.z === false);\n});\n\nit('computed properties can be reflected', async () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  el.a = -1;\n  el.b = 0;\n  assert(el.c === -1);\n  assert(el.negative === true);\n  assert(el.underline === true);\n\n  // We must await a microtask for the update to take place.\n  await Promise.resolve();\n  assert(el.hasAttribute('negative'));\n  assert(el.hasAttribute('underline'));\n});\n\nit('skips resolution when dependencies are the same', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let count = el.count;\n  el.countTrigger = 'foo';\n  assert(el.count === ++count);\n  el.countTrigger = 'foo';\n  el.countTrigger = 'foo';\n  el.countTrigger = 'foo';\n  el.countTrigger = 'foo';\n  assert(el.count === count);\n  el.countTrigger = 'bar';\n  assert(el.count === ++count);\n});\n\nit('lazily computes', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let count = el.count;\n  el.countTrigger = 'foo';\n  assert(el.count === ++count);\n  el.countTrigger = 'bar';\n  el.countTrigger = 'foo';\n  el.countTrigger = 'bar';\n  el.countTrigger = 'foo';\n  el.countTrigger = 'bar';\n  el.countTrigger = 'foo';\n  el.countTrigger = 'bar';\n  el.countTrigger = 'foo';\n  el.countTrigger = 'bar';\n  el.countTrigger = 'foo';\n  el.countTrigger = 'bar';\n  el.countTrigger = 'foo';\n  el.countTrigger = 'bar';\n  el.countTrigger = 'foo';\n  el.countTrigger = 'bar';\n  el.countTrigger = 'foo';\n  assert(el.count === count);\n  el.countTrigger = 'bar';\n  assert(el.count === ++count);\n});\n\nit('does correct NaN checking', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let count = el.count;\n  el.countTrigger = NaN;\n  assert(el.count === ++count);\n  el.countTrigger = NaN;\n  assert(el.count === count);\n});\n\nit('resets compute validity on initialization to catch upgrade edge cases with computed properties', () => {\n  const el = document.createElement('test-element-next');\n  el.setAttribute('a', '1');\n  el.setAttribute('b', '2');\n  assert(el.a === undefined);\n  assert(el.b === undefined);\n  assert(el.c === undefined);\n  document.body.append(el);\n  assert(el.a === 1);\n  assert(el.b === 2);\n  assert(el.c === 3);\n});\n\nit('cannot be written to from host', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.count = 0;\n  } catch (error) {\n    const expected = 'Property \"TestElement.prototype.count\" is computed (computed properties are read-only).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('cannot set to known properties', () => {\n  class BadTestElement extends XElement {\n    @property({\n      type: String,\n      input: [],\n      compute: () => {},\n    })\n    accessor computedProperty;\n\n    static template(host) {\n      host.computedProperty = 'Dromedary';\n      return html`<div>${host.computedProperty}</div>`;\n    }\n  }\n  customElements.define('bad-test-element-next-1', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Property \"BadTestElement.prototype.computedProperty\" is computed (computed properties are read-only).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('cannot compute a bad value', () => {\n  class BadTestElement extends XElement {\n    @property({\n      type: String,\n      input: [],\n      compute: () => 0,\n    })\n    accessor computedProperty;\n\n    static template(host) {\n      return html`${host.computedProperty}`;\n    }\n  }\n  customElements.define('bad-test-element-next-2', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Unexpected value for \"BadTestElement.prototype.computedProperty\" (expected String, got Number).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/test-next/test-computed-properties.src.js b/test-next/test-computed-properties.src.js new file mode 100644 index 0000000..d1e89fe --- /dev/null +++ b/test-next/test-computed-properties.src.js @@ -0,0 +1,315 @@ +import { it, assert } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; + +let _count = 0; + +class TestElement extends XElement { + static get styles() { + const styleSheet = new CSSStyleSheet(); + styleSheet.replaceSync(`\ + #calculation { + background-color: lightgreen; + padding: 10px; + } + + :host([negative]) #calculation { + background-color: lightcoral; + } + + :host([underline]) #calculation { + text-decoration: underline; + } + + :host([italic]) #calculation { + font-style: italic; + } + `); + return [styleSheet]; + } + + @property({ + type: Number, + input: ['a', 'b'], + compute: (a, b) => TestElement.#computeC(a, b), + }) + accessor #c; + + @property({ + type: Number, + input: ['#c'], + compute: (c) => c, + }) + accessor c; + + @property({ type: Number }) + accessor a; + + @property({ type: Number }) + accessor b; + + @property({ + type: Boolean, + input: ['#c'], + compute: c => c < 0, + reflect: true, + }) + accessor negative; + + @property({ + type: Boolean, + input: ['negative'], + compute: (negative) => TestElement.#computeUnderline(negative), + reflect: true, + }) + accessor underline; + + @property({ + type: Boolean, + reflect: true, + }) + accessor italic; + + @property({ type: Boolean }) + accessor y; + + @property({ + type: Boolean, + input: ['y'], + compute: (y) => TestElement.#computeZ(y), + }) + accessor z; + + @property({ type: Date }) + accessor today; + + @property({ + type: Date, + input: ['today'], + compute: (today) => TestElement.#computeTomorrow(today), + }) + accessor tomorrow; + + @property({}) + accessor countTrigger; + + @property({ + type: Number, + input: ['countTrigger'], + compute: () => TestElement.#computeCount(), + }) + accessor count; + + static #computeC(a, b) { + return a + b; + } + + static #computeCount() { + // This doesn't use an observer to prevent a coupled test. + return ++_count; + } + + static #computeUnderline(negative) { + return !!negative; + } + + static #computeZ(y) { + return y; + } + + static #computeTomorrow(today) { + if (today) { + return today.valueOf() + 1000 * 60 * 60 * 24; + } + } + + static template(host) { + return html`${host.a} + ${host.b} = ${host.#c}`; + } +} +customElements.define('test-element-next', TestElement); + +it('initializes as expected', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.a === undefined); + assert(el.b === undefined); + assert(el.y === undefined); + assert(el.z === undefined); + assert(el.countTrigger === undefined); + assert(Number.isNaN(el.c)); + assert(el.negative === false); + assert(el.underline === false); +}); + +it('properties are recomputed when dependencies change (a, b)', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.a = 1; + el.b = -2; + assert(el.a === 1); + assert(el.b === -2); + assert(el.c === -1); + assert(el.negative === true); + assert(el.underline === true); +}); + +it('properties are recomputed when dependencies change (y)', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.y = true; + assert(el.y === true); + assert(el.z === true); + el.y = false; + assert(el.y === false); + assert(el.z === false); +}); + +it('computed properties can be reflected', async () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.a = -1; + el.b = 0; + assert(el.c === -1); + assert(el.negative === true); + assert(el.underline === true); + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.hasAttribute('negative')); + assert(el.hasAttribute('underline')); +}); + +it('skips resolution when dependencies are the same', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let count = el.count; + el.countTrigger = 'foo'; + assert(el.count === ++count); + el.countTrigger = 'foo'; + el.countTrigger = 'foo'; + el.countTrigger = 'foo'; + el.countTrigger = 'foo'; + assert(el.count === count); + el.countTrigger = 'bar'; + assert(el.count === ++count); +}); + +it('lazily computes', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let count = el.count; + el.countTrigger = 'foo'; + assert(el.count === ++count); + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + el.countTrigger = 'bar'; + el.countTrigger = 'foo'; + assert(el.count === count); + el.countTrigger = 'bar'; + assert(el.count === ++count); +}); + +it('does correct NaN checking', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let count = el.count; + el.countTrigger = NaN; + assert(el.count === ++count); + el.countTrigger = NaN; + assert(el.count === count); +}); + +it('resets compute validity on initialization to catch upgrade edge cases with computed properties', () => { + const el = document.createElement('test-element-next'); + el.setAttribute('a', '1'); + el.setAttribute('b', '2'); + assert(el.a === undefined); + assert(el.b === undefined); + assert(el.c === undefined); + document.body.append(el); + assert(el.a === 1); + assert(el.b === 2); + assert(el.c === 3); +}); + +it('cannot be written to from host', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.count = 0; + } catch (error) { + const expected = 'Property "TestElement.prototype.count" is computed (computed properties are read-only).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('cannot set to known properties', () => { + class BadTestElement extends XElement { + @property({ + type: String, + input: [], + compute: () => {}, + }) + accessor computedProperty; + + static template(host) { + host.computedProperty = 'Dromedary'; + return html`
${host.computedProperty}
`; + } + } + customElements.define('bad-test-element-next-1', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Property "BadTestElement.prototype.computedProperty" is computed (computed properties are read-only).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('cannot compute a bad value', () => { + class BadTestElement extends XElement { + @property({ + type: String, + input: [], + compute: () => 0, + }) + accessor computedProperty; + + static template(host) { + return html`${host.computedProperty}`; + } + } + customElements.define('bad-test-element-next-2', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Unexpected value for "BadTestElement.prototype.computedProperty" (expected String, got Number).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); diff --git a/test-next/test-default-properties.html b/test-next/test-default-properties.html new file mode 100644 index 0000000..c666d0b --- /dev/null +++ b/test-next/test-default-properties.html @@ -0,0 +1,18 @@ + + + + + + + + +

Test Default Properties

+ + + diff --git a/test-next/test-default-properties.js b/test-next/test-default-properties.js new file mode 100644 index 0000000..8850ba5 --- /dev/null +++ b/test-next/test-default-properties.js @@ -0,0 +1,289 @@ +let _initProto, _oneDecs, _init_one, _initProto2, _oneDecs2, _init_one2, _twoDecs, _init_two, _initProto3, _oneDecs3, _init_one3, _twoDecs2, _init_two2, _initProto4, _oneDecs4, _init_one4, _twoDecs3, _init_two3, _threeDecs, _init_three; +function _applyDecs(e, t, r, n, o, a) { function i(e, t, r) { return function (n, o) { return r && r(n), e[t].call(n, o); }; } function c(e, t) { for (var r = 0; r < e.length; r++) e[r].call(t); return t; } function s(e, t, r, n) { if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); return e; } function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { function m(e) { if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); } var y, v = t[0], g = t[3], b = !u; if (!b) { r || Array.isArray(v) || (v = [v]); var w = {}, S = [], A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; f ? (p || d ? w = { get: _setFunctionName(function () { return g(this); }, n, "get"), set: function (e) { t[4](this, e); } } : w[A] = g, p || _setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); } for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { var D = v[j], E = r ? v[j - 1] : void 0, I = {}, O = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: n, metadata: a, addInitializer: function (e, t) { if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); s(t, "An initializer", "be", !0), c.push(t); }.bind(null, I) }; try { if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { var k, F; O.static = l, O.private = f, f ? 2 === o ? k = function (e) { return m(e), w.value; } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function (e) { return e[n]; }, (o < 2 || 4 === o) && (F = function (e, t) { e[n] = t; })); var N = O.access = { has: f ? h.bind() : function (e) { return n in e; } }; if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { get: w.get, set: w.set } : w[A], O), d) { if ("object" == typeof P && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); } } finally { I.v = !0; } } return (p || d) && u.push(function (e, t) { for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); return t; }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; } function u(e, t) { return Object.defineProperty(e, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: !0, enumerable: !0, value: t }); } if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol.for("Symbol.metadata")]; var f = Object.create(null == l ? null : l), p = function (e, t, r, n) { var o, a, i = [], s = function (t) { return _checkInRHS(t) === e; }, u = new Map(); function l(e) { e && i.push(c.bind(null, e)); } for (var f = 0; f < t.length; f++) { var p = t[f]; if (Array.isArray(p)) { var d = p[1], h = p[2], m = p.length > 3, y = 16 & d, v = !!(8 & d), g = 0 == (d &= 7), b = h + "/" + v; if (!g && !m) { var w = u.get(b); if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); u.set(b, !(d > 2) || d); } applyDec(v ? e : e.prototype, p, y, m ? "#" + h : _toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); } } return l(o), l(a), i; }(e, t, o, f); return r.length || u(e, f), { e: p, get c() { var t = []; return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; } }; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; } +function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; } +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; +class TestElementBasic extends XElement { + static { + [_init_one, _initProto] = _applyDecs(this, [[_oneDecs, 1, "one"]], [], 0, void 0, XElement).e; + } + #A = (_initProto(this), _init_one(this)); + get [(_oneDecs = property({ + type: String, + default: 'one' + }), "one")]() { + return this.#A; + } + set one(v) { + this.#A = v; + } + static template(host) { + return html`
${host.one}
`; + } +} +customElements.define('test-element-basic-next', TestElementBasic); +class TestElementAnonymous extends XElement { + static { + [_init_one2, _init_two, _initProto2] = _applyDecs(this, [[_oneDecs2, 1, "one"], [_twoDecs, 1, "two"]], [], 0, void 0, XElement).e; + } + #A = (_initProto2(this), _init_one2(this)); + get [(_oneDecs2 = property({ + type: String, + default: (() => 'one')() + }), _twoDecs = property({ + type: Object, + default: () => ({ + two: 'two' + }) + }), "one")]() { + return this.#A; + } + set one(v) { + this.#A = v; + } + #B = _init_two(this); + get two() { + return this.#B; + } + set two(v) { + this.#B = v; + } + static template(host) { + return html`
${host.one}, ${host.two.two}
`; + } +} +customElements.define('test-element-anonymous-next', TestElementAnonymous); +class TestElementStatic extends XElement { + static { + [_init_one3, _init_two2, _initProto3] = _applyDecs(this, [[_oneDecs3, 1, "one"], [_twoDecs2, 1, "two"]], [], 0, void 0, XElement).e; + } + static get [(_oneDecs3 = property({ + type: String, + default: () => TestElementStatic.getOne() + }), _twoDecs2 = property({ + type: Object, + default: () => TestElementStatic.getTwo() + }), "one")]() { + return 'one'; + } + static getOne() { + return this.one; + } + static get two() { + return { + two: 'two' + }; + } + static getTwo() { + return this.two; + } + #A = (_initProto3(this), _init_one3(this)); + get one() { + return this.#A; + } + set one(v) { + this.#A = v; + } + #B = _init_two2(this); + get two() { + return this.#B; + } + set two(v) { + this.#B = v; + } + static template(host) { + return html`
${host.one}, ${host.two.two}
`; + } +} +customElements.define('test-element-static-next', TestElementStatic); +class TestElementEdge extends XElement { + static { + [_init_one4, _init_two3, _init_three, _initProto4] = _applyDecs(this, [[_oneDecs4, 1, "one"], [_twoDecs3, 1, "two"], [_threeDecs, 1, "three"]], [], 0, void 0, XElement).e; + } + #A = (_initProto4(this), _init_one4(this)); + get [(_oneDecs4 = property({ + type: String, + initial: undefined, + default: 'one' + }), _twoDecs3 = property({ + type: Object, + initial: null, + default: () => ({ + two: 'two' + }) + }), _threeDecs = property({ + type: String, + input: [], + compute: () => {}, + default: 'three' + }), "one")]() { + return this.#A; + } + set one(v) { + this.#A = v; + } + #B = _init_two3(this); + get two() { + return this.#B; + } + set two(v) { + this.#B = v; + } + #C = _init_three(this); + get three() { + return this.#C; + } + set three(v) { + this.#C = v; + } + static template(host) { + return html`
${host.one}, ${host.two.two}, ${host.three}
`; + } +} +customElements.define('test-element-edge-next', TestElementEdge); +it('basic default properties', async () => { + const el = document.createElement('test-element-basic-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'one'); + + // Test that we can override the default. + el.one = 'ONE'; + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'ONE'); + + // Test that we get our default back via undefined. + el.one = undefined; + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'one'); + + // Override again... + el.one = 'ONE'; + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'ONE'); + + // Test that we get our default back via null. + el.one = null; + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'one'); +}); +it('basic default properties (predefined undefined properties)', () => { + const el = document.createElement('test-element-basic-next'); + el.one = undefined; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one'); +}); +it('basic default properties (predefined null properties)', () => { + const el = document.createElement('test-element-basic-next'); + el.one = null; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one'); +}); +it('basic default properties (predefined properties)', () => { + const el = document.createElement('test-element-basic-next'); + el.one = 'ONE'; + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE'); +}); +it('basic default properties (predefined attributes)', () => { + const el = document.createElement('test-element-basic-next'); + el.setAttribute('one', 'ONE'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE'); +}); +it('anonymous default properties', () => { + const el = document.createElement('test-element-anonymous-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two'); +}); +it('anonymous default properties (predefined undefined properties)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.one = undefined; + el.two = undefined; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two'); +}); +it('anonymous default properties (predefined null properties)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.one = null; + el.two = null; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two'); +}); +it('anonymous default properties (predefined properties)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.one = 'ONE'; + el.two = { + two: 'TWO' + }; + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE, TWO'); +}); +it('anonymous default properties (predefined attributes)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.setAttribute('one', 'ONE'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE, two'); +}); +it('initial + default & computed + default properties', () => { + const el = document.createElement('test-element-edge-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two, three'); +}); +it('default values from functions are unique per instance', () => { + const el1 = document.createElement('test-element-edge-next'); + const el2 = document.createElement('test-element-edge-next'); + document.body.append(el1, el2); + assert(el1.shadowRoot.textContent === 'one, two, three'); + assert(el2.shadowRoot.textContent === 'one, two, three'); + assert(el1.two !== el2.two); +}); +it('default values from functions persist per instance', async () => { + const el = document.createElement('test-element-edge-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two, three'); + const defaultTwo = el.two; + el.two = { + two: 'TWO' + }; + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'one, TWO, three'); + assert(el.two !== defaultTwo); + el.two = undefined; + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'one, two, three'); + assert(el.two === defaultTwo); +}); +it('cannot set default to a bad type', () => { + let _initProto5, _badDecs, _init_bad; + class BadTestElement extends XElement { + static { + [_init_bad, _initProto5] = _applyDecs(this, [[_badDecs, 1, "bad"]], [], 0, void 0, XElement).e; + } + #A = (_initProto5(this), _init_bad(this)); + get [(_badDecs = property({ + type: String, + default: 0 + }), "bad")]() { + return this.#A; + } + set bad(v) { + this.#A = v; + } + } + customElements.define('bad-test-element-next-1', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Unexpected value for "BadTestElement.prototype.bad" (expected String, got Number).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["assert","it","XElement","property","html","TestElementBasic","_init_one","_initProto","_applyDecs","_oneDecs","e","A","type","String","default","one","v","template","host","customElements","define","TestElementAnonymous","_init_one2","_init_two","_initProto2","_oneDecs2","_twoDecs","Object","two","B","TestElementStatic","_init_one3","_init_two2","_initProto3","_oneDecs3","_twoDecs2","getOne","getTwo","TestElementEdge","_init_one4","_init_two3","_init_three","_initProto4","_oneDecs4","_twoDecs3","_threeDecs","initial","undefined","input","compute","C","three","el","document","createElement","body","append","shadowRoot","textContent","Promise","resolve","setAttribute","el1","el2","defaultTwo","_initProto5","_badDecs","_init_bad","BadTestElement","bad","passed","message","connectedCallback","error","expected"],"sources":["test-default-properties.src.js"],"sourcesContent":["import { assert, it } from '@netflix/x-test/x-test.js';\nimport { XElement, property, html } from '../x-element-next.js';\n\nclass TestElementBasic extends XElement {\n  @property({ type: String, default: 'one' })\n  accessor one;\n\n  static template(host) {\n    return html`<div>${host.one}</div>`;\n  }\n}\ncustomElements.define('test-element-basic-next', TestElementBasic);\n\nclass TestElementAnonymous extends XElement {\n  @property({ type: String, default: (() => 'one')() })\n  accessor one;\n\n  @property({ type: Object, default: () => ({ two: 'two' }) })\n  accessor two;\n\n  static template(host) {\n    return html`<div>${host.one}, ${host.two.two}</div>`;\n  }\n}\ncustomElements.define('test-element-anonymous-next', TestElementAnonymous);\n\nclass TestElementStatic extends XElement {\n  static get one() {\n    return 'one';\n  }\n  static getOne() {\n    return this.one;\n  }\n  static get two() {\n    return { two: 'two' };\n  }\n  static getTwo() {\n    return this.two;\n  }\n\n  @property({ type: String, default: () => TestElementStatic.getOne() })\n  accessor one;\n\n  @property({ type: Object, default: () => TestElementStatic.getTwo() })\n  accessor two;\n\n  static template(host) {\n    return html`<div>${host.one}, ${host.two.two}</div>`;\n  }\n}\ncustomElements.define('test-element-static-next', TestElementStatic);\n\nclass TestElementEdge extends XElement {\n  @property({ type: String, initial: undefined, default: 'one' })\n  accessor one;\n\n  @property({ type: Object, initial: null, default: () => ({ two: 'two' }) })\n  accessor two;\n\n  @property({ type: String, input: [], compute: () => {}, default: 'three' })\n  accessor three;\n\n  static template(host) {\n    return html`<div>${host.one}, ${host.two.two}, ${host.three}</div>`;\n  }\n}\ncustomElements.define('test-element-edge-next', TestElementEdge);\n\nit('basic default properties', async () => {\n  const el = document.createElement('test-element-basic-next');\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one');\n\n  // Test that we can override the default.\n  el.one = 'ONE';\n  await Promise.resolve();\n  assert(el.shadowRoot.textContent === 'ONE');\n\n  // Test that we get our default back via undefined.\n  el.one = undefined;\n  await Promise.resolve();\n  assert(el.shadowRoot.textContent === 'one');\n\n  // Override again...\n  el.one = 'ONE';\n  await Promise.resolve();\n  assert(el.shadowRoot.textContent === 'ONE');\n\n  // Test that we get our default back via null.\n  el.one = null;\n  await Promise.resolve();\n  assert(el.shadowRoot.textContent === 'one');\n});\n\nit('basic default properties (predefined undefined properties)', () => {\n  const el = document.createElement('test-element-basic-next');\n  el.one = undefined;\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one');\n});\n\nit('basic default properties (predefined null properties)', () => {\n  const el = document.createElement('test-element-basic-next');\n  el.one = null;\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one');\n});\n\nit('basic default properties (predefined properties)', () => {\n  const el = document.createElement('test-element-basic-next');\n  el.one = 'ONE';\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'ONE');\n});\n\nit('basic default properties (predefined attributes)', () => {\n  const el = document.createElement('test-element-basic-next');\n  el.setAttribute('one', 'ONE');\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'ONE');\n});\n\nit('anonymous default properties', () => {\n  const el = document.createElement('test-element-anonymous-next');\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one, two');\n});\n\nit('anonymous default properties (predefined undefined properties)', () => {\n  const el = document.createElement('test-element-anonymous-next');\n  el.one = undefined;\n  el.two = undefined;\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one, two');\n});\n\nit('anonymous default properties (predefined null properties)', () => {\n  const el = document.createElement('test-element-anonymous-next');\n  el.one = null;\n  el.two = null;\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one, two');\n});\n\nit('anonymous default properties (predefined properties)', () => {\n  const el = document.createElement('test-element-anonymous-next');\n  el.one = 'ONE';\n  el.two = { two: 'TWO' };\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'ONE, TWO');\n});\n\nit('anonymous default properties (predefined attributes)', () => {\n  const el = document.createElement('test-element-anonymous-next');\n  el.setAttribute('one', 'ONE');\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'ONE, two');\n});\n\nit('initial + default & computed + default properties', () => {\n  const el = document.createElement('test-element-edge-next');\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one, two, three');\n});\n\nit('default values from functions are unique per instance', () => {\n  const el1 = document.createElement('test-element-edge-next');\n  const el2 = document.createElement('test-element-edge-next');\n  document.body.append(el1, el2);\n  assert(el1.shadowRoot.textContent === 'one, two, three');\n  assert(el2.shadowRoot.textContent === 'one, two, three');\n  assert(el1.two !== el2.two);\n});\n\nit('default values from functions persist per instance', async () => {\n  const el = document.createElement('test-element-edge-next');\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one, two, three');\n  const defaultTwo = el.two;\n  el.two = { two: 'TWO' };\n  await Promise.resolve();\n  assert(el.shadowRoot.textContent === 'one, TWO, three');\n  assert(el.two !== defaultTwo);\n  el.two = undefined;\n  await Promise.resolve();\n  assert(el.shadowRoot.textContent === 'one, two, three');\n  assert(el.two === defaultTwo);\n});\n\nit('cannot set default to a bad type', () => {\n  class BadTestElement extends XElement {\n    @property({ type: String, default: 0 })\n    accessor bad;\n  }\n  customElements.define('bad-test-element-next-1', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Unexpected value for \"BadTestElement.prototype.bad\" (expected String, got Number).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/test-next/test-default-properties.src.js b/test-next/test-default-properties.src.js new file mode 100644 index 0000000..b502597 --- /dev/null +++ b/test-next/test-default-properties.src.js @@ -0,0 +1,207 @@ +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; + +class TestElementBasic extends XElement { + @property({ type: String, default: 'one' }) + accessor one; + + static template(host) { + return html`
${host.one}
`; + } +} +customElements.define('test-element-basic-next', TestElementBasic); + +class TestElementAnonymous extends XElement { + @property({ type: String, default: (() => 'one')() }) + accessor one; + + @property({ type: Object, default: () => ({ two: 'two' }) }) + accessor two; + + static template(host) { + return html`
${host.one}, ${host.two.two}
`; + } +} +customElements.define('test-element-anonymous-next', TestElementAnonymous); + +class TestElementStatic extends XElement { + static get one() { + return 'one'; + } + static getOne() { + return this.one; + } + static get two() { + return { two: 'two' }; + } + static getTwo() { + return this.two; + } + + @property({ type: String, default: () => TestElementStatic.getOne() }) + accessor one; + + @property({ type: Object, default: () => TestElementStatic.getTwo() }) + accessor two; + + static template(host) { + return html`
${host.one}, ${host.two.two}
`; + } +} +customElements.define('test-element-static-next', TestElementStatic); + +class TestElementEdge extends XElement { + @property({ type: String, initial: undefined, default: 'one' }) + accessor one; + + @property({ type: Object, initial: null, default: () => ({ two: 'two' }) }) + accessor two; + + @property({ type: String, input: [], compute: () => {}, default: 'three' }) + accessor three; + + static template(host) { + return html`
${host.one}, ${host.two.two}, ${host.three}
`; + } +} +customElements.define('test-element-edge-next', TestElementEdge); + +it('basic default properties', async () => { + const el = document.createElement('test-element-basic-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'one'); + + // Test that we can override the default. + el.one = 'ONE'; + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'ONE'); + + // Test that we get our default back via undefined. + el.one = undefined; + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'one'); + + // Override again... + el.one = 'ONE'; + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'ONE'); + + // Test that we get our default back via null. + el.one = null; + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'one'); +}); + +it('basic default properties (predefined undefined properties)', () => { + const el = document.createElement('test-element-basic-next'); + el.one = undefined; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one'); +}); + +it('basic default properties (predefined null properties)', () => { + const el = document.createElement('test-element-basic-next'); + el.one = null; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one'); +}); + +it('basic default properties (predefined properties)', () => { + const el = document.createElement('test-element-basic-next'); + el.one = 'ONE'; + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE'); +}); + +it('basic default properties (predefined attributes)', () => { + const el = document.createElement('test-element-basic-next'); + el.setAttribute('one', 'ONE'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE'); +}); + +it('anonymous default properties', () => { + const el = document.createElement('test-element-anonymous-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two'); +}); + +it('anonymous default properties (predefined undefined properties)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.one = undefined; + el.two = undefined; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two'); +}); + +it('anonymous default properties (predefined null properties)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.one = null; + el.two = null; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two'); +}); + +it('anonymous default properties (predefined properties)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.one = 'ONE'; + el.two = { two: 'TWO' }; + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE, TWO'); +}); + +it('anonymous default properties (predefined attributes)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.setAttribute('one', 'ONE'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE, two'); +}); + +it('initial + default & computed + default properties', () => { + const el = document.createElement('test-element-edge-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two, three'); +}); + +it('default values from functions are unique per instance', () => { + const el1 = document.createElement('test-element-edge-next'); + const el2 = document.createElement('test-element-edge-next'); + document.body.append(el1, el2); + assert(el1.shadowRoot.textContent === 'one, two, three'); + assert(el2.shadowRoot.textContent === 'one, two, three'); + assert(el1.two !== el2.two); +}); + +it('default values from functions persist per instance', async () => { + const el = document.createElement('test-element-edge-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two, three'); + const defaultTwo = el.two; + el.two = { two: 'TWO' }; + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'one, TWO, three'); + assert(el.two !== defaultTwo); + el.two = undefined; + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'one, two, three'); + assert(el.two === defaultTwo); +}); + +it('cannot set default to a bad type', () => { + class BadTestElement extends XElement { + @property({ type: String, default: 0 }) + accessor bad; + } + customElements.define('bad-test-element-next-1', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Unexpected value for "BadTestElement.prototype.bad" (expected String, got Number).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); diff --git a/test-next/test-element-upgrade.html b/test-next/test-element-upgrade.html new file mode 100644 index 0000000..17bd322 --- /dev/null +++ b/test-next/test-element-upgrade.html @@ -0,0 +1,18 @@ + + + + + + + + +

Test Element Upgrade

+ + + diff --git a/test-next/test-element-upgrade.js b/test-next/test-element-upgrade.js new file mode 100644 index 0000000..68dc405 --- /dev/null +++ b/test-next/test-element-upgrade.js @@ -0,0 +1,114 @@ +function _applyDecs(e, t, r, n, o, a) { function i(e, t, r) { return function (n, o) { return r && r(n), e[t].call(n, o); }; } function c(e, t) { for (var r = 0; r < e.length; r++) e[r].call(t); return t; } function s(e, t, r, n) { if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); return e; } function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { function m(e) { if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); } var y, v = t[0], g = t[3], b = !u; if (!b) { r || Array.isArray(v) || (v = [v]); var w = {}, S = [], A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; f ? (p || d ? w = { get: _setFunctionName(function () { return g(this); }, n, "get"), set: function (e) { t[4](this, e); } } : w[A] = g, p || _setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); } for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { var D = v[j], E = r ? v[j - 1] : void 0, I = {}, O = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: n, metadata: a, addInitializer: function (e, t) { if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); s(t, "An initializer", "be", !0), c.push(t); }.bind(null, I) }; try { if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { var k, F; O.static = l, O.private = f, f ? 2 === o ? k = function (e) { return m(e), w.value; } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function (e) { return e[n]; }, (o < 2 || 4 === o) && (F = function (e, t) { e[n] = t; })); var N = O.access = { has: f ? h.bind() : function (e) { return n in e; } }; if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { get: w.get, set: w.set } : w[A], O), d) { if ("object" == typeof P && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); } } finally { I.v = !0; } } return (p || d) && u.push(function (e, t) { for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); return t; }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; } function u(e, t) { return Object.defineProperty(e, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: !0, enumerable: !0, value: t }); } if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol.for("Symbol.metadata")]; var f = Object.create(null == l ? null : l), p = function (e, t, r, n) { var o, a, i = [], s = function (t) { return _checkInRHS(t) === e; }, u = new Map(); function l(e) { e && i.push(c.bind(null, e)); } for (var f = 0; f < t.length; f++) { var p = t[f]; if (Array.isArray(p)) { var d = p[1], h = p[2], m = p.length > 3, y = 16 & d, v = !!(8 & d), g = 0 == (d &= 7), b = h + "/" + v; if (!g && !m) { var w = u.get(b); if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); u.set(b, !(d > 2) || d); } applyDec(v ? e : e.prototype, p, y, m ? "#" + h : _toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); } } return l(o), l(a), i; }(e, t, o, f); return r.length || u(e, f), { e: p, get c() { var t = []; return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; } }; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; } +function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; } +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; +export default class TestElement extends XElement { + constructor() { + super(); + this._readOnlyProperty = 'didelphidae'; + this._readOnlyKey = 'didelphimorphia'; + Reflect.defineProperty(this, 'readOnlyDefinedProperty', { + value: 'phalangeriformes', + configurable: false + }); + } + connectedCallback() { + super.connectedCallback(); + this.shadowRoot.firstElementChild.textContent = this.readOnlyProperty; + } + static template() { + return html`
`; + } + get readOnlyProperty() { + return this._readOnlyProperty; + } + get [Symbol.for('readOnlyKey')]() { + return this._readOnlyKey; + } + get reflectedProperty() { + return this.getAttribute('reflected-property'); + } + set reflectedProperty(value) { + this.setAttribute('reflected-property', value); + } +} +const setupEl = el => { + el.className = 'marsupialia'; + el.readOnlyProperty = 'chlamyphoridae'; + el[Symbol.for('readOnlyKey')] = 'dasypodidae'; + el.reflectedProperty = 'plantigrade'; +}; +const hasNotUpgraded = el => { + return el instanceof HTMLElement && el instanceof TestElement === false && el.shadowRoot === null && el.getAttribute('class') === 'marsupialia' && el.readOnlyProperty === 'chlamyphoridae' && el[Symbol.for('readOnlyKey')] === 'dasypodidae' && el.readOnlyDefinedProperty === undefined && el.reflectedProperty === 'plantigrade' && el.getAttribute('reflected-property') === null; +}; +const hasUpgraded = el => { + // Properties are still shadowed after upgrade and before initialization. + return el instanceof TestElement && el.getAttribute('class') === 'marsupialia' && el.readOnlyProperty === 'didelphidae' && el[Symbol.for('readOnlyKey')] === 'didelphimorphia' && el.readOnlyDefinedProperty === 'phalangeriformes' && el.reflectedProperty === 'plantigrade' && el.getAttribute('reflected-property') === 'plantigrade'; +}; +it('x-element upgrade lifecycle', () => { + const localName = 'test-element-next'; + assert(customElements.get(localName) === undefined, 'localName is initially undefined'); + const el1 = document.createElement(localName); + el1.id = 'el1'; + setupEl(el1); + document.body.append(el1); + const el2 = document.createElement(localName); + el2.id = 'el2'; + setupEl(el2); + assert(el1.localName === localName && document.getElementById('el1') === el1 && hasNotUpgraded(el1), 'el1 is setup as expected'); + assert(el1.localName === localName && document.getElementById('el2') === null && hasNotUpgraded(el2), 'el2 is setup as expected'); + customElements.define(localName, TestElement); + const el3 = document.createElement(localName); + el3.id = 'el3'; + el3.className = 'marsupialia'; + el3.reflectedProperty = 'plantigrade'; + const el4 = new TestElement(); + el4.id = 'el4'; + el4.className = 'marsupialia'; + el4.reflectedProperty = 'plantigrade'; + assert(hasUpgraded(el3) && hasUpgraded(el4), 'elements created after definition do not need upgrading'); + assert(hasUpgraded(el1), 'element in document is upgraded upon definition'); + assert(el1.shadowRoot.textContent === 'didelphidae', 'element in document synchronously renders'); + assert(hasNotUpgraded(el2), 'element out of document is still not upgraded'); + document.body.append(el2); + assert(el2.shadowRoot.textContent === 'didelphidae', 'element out of document upgrades/renders after being added'); + document.body.append(el3); + assert(el3.shadowRoot.textContent === 'didelphidae', 'element created after definition upgrades/renders after being added'); +}); +it('preserves x-element properties set before customElements.define', () => { + let _initProto, _fooDecs, _init_foo, _barDecs, _init_bar; + class PreUpgradeElement extends XElement { + static { + [_init_foo, _init_bar, _initProto] = _applyDecs(this, [[_fooDecs, 1, "foo"], [_barDecs, 1, "bar"]], [], 0, void 0, XElement).e; + } + #A = (_initProto(this), _init_foo(this)); + get [(_fooDecs = property({ + type: String + }), _barDecs = property({ + type: Number + }), "foo")]() { + return this.#A; + } + set foo(v) { + this.#A = v; + } + #B = _init_bar(this); + get bar() { + return this.#B; + } + set bar(v) { + this.#B = v; + } + } + const el = document.createElement('pre-upgrade-element-next'); + el.foo = 'test'; + el.bar = 42; + customElements.define('pre-upgrade-element-next', PreUpgradeElement); + document.body.append(el); + assert(el.foo === 'test'); + assert(el.bar === 42); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["assert","it","XElement","property","html","TestElement","constructor","_readOnlyProperty","_readOnlyKey","Reflect","defineProperty","value","configurable","connectedCallback","shadowRoot","firstElementChild","textContent","readOnlyProperty","template","Symbol","for","reflectedProperty","getAttribute","setAttribute","setupEl","el","className","hasNotUpgraded","HTMLElement","readOnlyDefinedProperty","undefined","hasUpgraded","localName","customElements","get","el1","document","createElement","id","body","append","el2","getElementById","define","el3","el4","_initProto","_fooDecs","_init_foo","_barDecs","_init_bar","PreUpgradeElement","_applyDecs","e","A","type","String","Number","foo","v","B","bar"],"sources":["test-element-upgrade.src.js"],"sourcesContent":["import { assert, it } from '@netflix/x-test/x-test.js';\nimport { XElement, property, html } from '../x-element-next.js';\n\nexport default class TestElement extends XElement {\n  constructor() {\n    super();\n    this._readOnlyProperty = 'didelphidae';\n    this._readOnlyKey = 'didelphimorphia';\n    Reflect.defineProperty(this, 'readOnlyDefinedProperty', {\n      value: 'phalangeriformes',\n      configurable: false,\n    });\n  }\n\n  connectedCallback() {\n    super.connectedCallback();\n    this.shadowRoot.firstElementChild.textContent = this.readOnlyProperty;\n  }\n\n  static template() {\n    return html`<div></div>`;\n  }\n\n  get readOnlyProperty() {\n    return this._readOnlyProperty;\n  }\n\n  get [Symbol.for('readOnlyKey')]() {\n    return this._readOnlyKey;\n  }\n\n  get reflectedProperty() {\n    return this.getAttribute('reflected-property');\n  }\n\n  set reflectedProperty(value) {\n    this.setAttribute('reflected-property', value);\n  }\n}\n\nconst setupEl = el => {\n  el.className = 'marsupialia';\n  el.readOnlyProperty = 'chlamyphoridae';\n  el[Symbol.for('readOnlyKey')] = 'dasypodidae';\n  el.reflectedProperty = 'plantigrade';\n};\n\nconst hasNotUpgraded = el => {\n  return (\n    el instanceof HTMLElement &&\n    el instanceof TestElement === false &&\n    el.shadowRoot === null &&\n    el.getAttribute('class') === 'marsupialia' &&\n    el.readOnlyProperty === 'chlamyphoridae' &&\n    el[Symbol.for('readOnlyKey')] === 'dasypodidae' &&\n    el.readOnlyDefinedProperty === undefined &&\n    el.reflectedProperty === 'plantigrade' &&\n    el.getAttribute('reflected-property') === null\n  );\n};\n\nconst hasUpgraded = el => {\n  // Properties are still shadowed after upgrade and before initialization.\n  return (\n    el instanceof TestElement &&\n    el.getAttribute('class') === 'marsupialia' &&\n    el.readOnlyProperty === 'didelphidae' &&\n    el[Symbol.for('readOnlyKey')] === 'didelphimorphia' &&\n    el.readOnlyDefinedProperty === 'phalangeriformes' &&\n    el.reflectedProperty === 'plantigrade' &&\n    el.getAttribute('reflected-property') === 'plantigrade'\n  );\n};\n\nit('x-element upgrade lifecycle', () => {\n  const localName = 'test-element-next';\n  assert(\n    customElements.get(localName) === undefined,\n    'localName is initially undefined'\n  );\n\n  const el1 = document.createElement(localName);\n  el1.id = 'el1';\n  setupEl(el1);\n  document.body.append(el1);\n\n  const el2 = document.createElement(localName);\n  el2.id = 'el2';\n  setupEl(el2);\n\n  assert(\n    el1.localName === localName &&\n      document.getElementById('el1') === el1 &&\n      hasNotUpgraded(el1),\n    'el1 is setup as expected'\n  );\n\n  assert(\n    el1.localName === localName &&\n      document.getElementById('el2') === null &&\n      hasNotUpgraded(el2),\n    'el2 is setup as expected'\n  );\n\n  customElements.define(localName, TestElement);\n\n  const el3 = document.createElement(localName);\n  el3.id = 'el3';\n  el3.className = 'marsupialia';\n  el3.reflectedProperty = 'plantigrade';\n\n  const el4 = new TestElement();\n  el4.id = 'el4';\n  el4.className = 'marsupialia';\n  el4.reflectedProperty = 'plantigrade';\n\n  assert(\n    hasUpgraded(el3) && hasUpgraded(el4),\n    'elements created after definition do not need upgrading'\n  );\n\n  assert(hasUpgraded(el1), 'element in document is upgraded upon definition');\n  assert(\n    el1.shadowRoot.textContent === 'didelphidae',\n    'element in document synchronously renders'\n  );\n\n  assert(hasNotUpgraded(el2), 'element out of document is still not upgraded');\n  document.body.append(el2);\n  assert(\n    el2.shadowRoot.textContent === 'didelphidae',\n    'element out of document upgrades/renders after being added'\n  );\n\n  document.body.append(el3);\n  assert(\n    el3.shadowRoot.textContent === 'didelphidae',\n    'element created after definition upgrades/renders after being added'\n  );\n});\n\nit('preserves x-element properties set before customElements.define', () => {\n  class PreUpgradeElement extends XElement {\n    @property({\n      type: String,\n    })\n    accessor foo;\n\n    @property({\n      type: Number,\n    })\n    accessor bar;\n  }\n  const el = document.createElement('pre-upgrade-element-next');\n  el.foo = 'test';\n  el.bar = 42;\n  customElements.define('pre-upgrade-element-next', PreUpgradeElement);\n  document.body.append(el);\n  assert(el.foo === 'test');\n  assert(el.bar === 42);\n});\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/test-next/test-element-upgrade.src.js b/test-next/test-element-upgrade.src.js new file mode 100644 index 0000000..54d2e69 --- /dev/null +++ b/test-next/test-element-upgrade.src.js @@ -0,0 +1,161 @@ +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; + +export default class TestElement extends XElement { + constructor() { + super(); + this._readOnlyProperty = 'didelphidae'; + this._readOnlyKey = 'didelphimorphia'; + Reflect.defineProperty(this, 'readOnlyDefinedProperty', { + value: 'phalangeriformes', + configurable: false, + }); + } + + connectedCallback() { + super.connectedCallback(); + this.shadowRoot.firstElementChild.textContent = this.readOnlyProperty; + } + + static template() { + return html`
`; + } + + get readOnlyProperty() { + return this._readOnlyProperty; + } + + get [Symbol.for('readOnlyKey')]() { + return this._readOnlyKey; + } + + get reflectedProperty() { + return this.getAttribute('reflected-property'); + } + + set reflectedProperty(value) { + this.setAttribute('reflected-property', value); + } +} + +const setupEl = el => { + el.className = 'marsupialia'; + el.readOnlyProperty = 'chlamyphoridae'; + el[Symbol.for('readOnlyKey')] = 'dasypodidae'; + el.reflectedProperty = 'plantigrade'; +}; + +const hasNotUpgraded = el => { + return ( + el instanceof HTMLElement && + el instanceof TestElement === false && + el.shadowRoot === null && + el.getAttribute('class') === 'marsupialia' && + el.readOnlyProperty === 'chlamyphoridae' && + el[Symbol.for('readOnlyKey')] === 'dasypodidae' && + el.readOnlyDefinedProperty === undefined && + el.reflectedProperty === 'plantigrade' && + el.getAttribute('reflected-property') === null + ); +}; + +const hasUpgraded = el => { + // Properties are still shadowed after upgrade and before initialization. + return ( + el instanceof TestElement && + el.getAttribute('class') === 'marsupialia' && + el.readOnlyProperty === 'didelphidae' && + el[Symbol.for('readOnlyKey')] === 'didelphimorphia' && + el.readOnlyDefinedProperty === 'phalangeriformes' && + el.reflectedProperty === 'plantigrade' && + el.getAttribute('reflected-property') === 'plantigrade' + ); +}; + +it('x-element upgrade lifecycle', () => { + const localName = 'test-element-next'; + assert( + customElements.get(localName) === undefined, + 'localName is initially undefined' + ); + + const el1 = document.createElement(localName); + el1.id = 'el1'; + setupEl(el1); + document.body.append(el1); + + const el2 = document.createElement(localName); + el2.id = 'el2'; + setupEl(el2); + + assert( + el1.localName === localName && + document.getElementById('el1') === el1 && + hasNotUpgraded(el1), + 'el1 is setup as expected' + ); + + assert( + el1.localName === localName && + document.getElementById('el2') === null && + hasNotUpgraded(el2), + 'el2 is setup as expected' + ); + + customElements.define(localName, TestElement); + + const el3 = document.createElement(localName); + el3.id = 'el3'; + el3.className = 'marsupialia'; + el3.reflectedProperty = 'plantigrade'; + + const el4 = new TestElement(); + el4.id = 'el4'; + el4.className = 'marsupialia'; + el4.reflectedProperty = 'plantigrade'; + + assert( + hasUpgraded(el3) && hasUpgraded(el4), + 'elements created after definition do not need upgrading' + ); + + assert(hasUpgraded(el1), 'element in document is upgraded upon definition'); + assert( + el1.shadowRoot.textContent === 'didelphidae', + 'element in document synchronously renders' + ); + + assert(hasNotUpgraded(el2), 'element out of document is still not upgraded'); + document.body.append(el2); + assert( + el2.shadowRoot.textContent === 'didelphidae', + 'element out of document upgrades/renders after being added' + ); + + document.body.append(el3); + assert( + el3.shadowRoot.textContent === 'didelphidae', + 'element created after definition upgrades/renders after being added' + ); +}); + +it('preserves x-element properties set before customElements.define', () => { + class PreUpgradeElement extends XElement { + @property({ + type: String, + }) + accessor foo; + + @property({ + type: Number, + }) + accessor bar; + } + const el = document.createElement('pre-upgrade-element-next'); + el.foo = 'test'; + el.bar = 42; + customElements.define('pre-upgrade-element-next', PreUpgradeElement); + document.body.append(el); + assert(el.foo === 'test'); + assert(el.bar === 42); +}); diff --git a/test-next/test-inheritance.html b/test-next/test-inheritance.html new file mode 100644 index 0000000..2ac2f7f --- /dev/null +++ b/test-next/test-inheritance.html @@ -0,0 +1,18 @@ + + + + + + + + +

Test Inheritance

+ + + diff --git a/test-next/test-inheritance.js b/test-next/test-inheritance.js new file mode 100644 index 0000000..fcf4de2 --- /dev/null +++ b/test-next/test-inheritance.js @@ -0,0 +1,679 @@ +let _initProto, _parentPropDecs, _init_parentProp, _sharedPropDecs, _init_sharedProp, _initProto2, _childPropDecs, _init_childProp, _sharedPropDecs2, _init_sharedProp2, _initProto3, _initStatic, _parentClicksDecs, _init_parentClicks, _onParentEventDecs, _initProto4, _initStatic2, _childClicksDecs, _init_childClicks, _onChildEventDecs, _initProto5, _levelDecs, _init_level, _generationDecs, _init_generation, _initProto6, _levelDecs2, _init_level2, _generationDecs2, _init_generation2, _initProto7, _levelDecs3, _init_level3, _generationDecs3, _init_generation3; +function _applyDecs(e, t, r, n, o, a) { function i(e, t, r) { return function (n, o) { return r && r(n), e[t].call(n, o); }; } function c(e, t) { for (var r = 0; r < e.length; r++) e[r].call(t); return t; } function s(e, t, r, n) { if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); return e; } function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { function m(e) { if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); } var y, v = t[0], g = t[3], b = !u; if (!b) { r || Array.isArray(v) || (v = [v]); var w = {}, S = [], A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; f ? (p || d ? w = { get: _setFunctionName(function () { return g(this); }, n, "get"), set: function (e) { t[4](this, e); } } : w[A] = g, p || _setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); } for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { var D = v[j], E = r ? v[j - 1] : void 0, I = {}, O = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: n, metadata: a, addInitializer: function (e, t) { if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); s(t, "An initializer", "be", !0), c.push(t); }.bind(null, I) }; try { if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { var k, F; O.static = l, O.private = f, f ? 2 === o ? k = function (e) { return m(e), w.value; } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function (e) { return e[n]; }, (o < 2 || 4 === o) && (F = function (e, t) { e[n] = t; })); var N = O.access = { has: f ? h.bind() : function (e) { return n in e; } }; if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { get: w.get, set: w.set } : w[A], O), d) { if ("object" == typeof P && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); } } finally { I.v = !0; } } return (p || d) && u.push(function (e, t) { for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); return t; }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; } function u(e, t) { return Object.defineProperty(e, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: !0, enumerable: !0, value: t }); } if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol.for("Symbol.metadata")]; var f = Object.create(null == l ? null : l), p = function (e, t, r, n) { var o, a, i = [], s = function (t) { return _checkInRHS(t) === e; }, u = new Map(); function l(e) { e && i.push(c.bind(null, e)); } for (var f = 0; f < t.length; f++) { var p = t[f]; if (Array.isArray(p)) { var d = p[1], h = p[2], m = p.length > 3, y = 16 & d, v = !!(8 & d), g = 0 == (d &= 7), b = h + "/" + v; if (!g && !m) { var w = u.get(b); if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); u.set(b, !(d > 2) || d); } applyDec(v ? e : e.prototype, p, y, m ? "#" + h : _toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); } } return l(o), l(a), i; }(e, t, o, f); return r.length || u(e, f), { e: p, get c() { var t = []; return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; } }; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; } +function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; } +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, listener, html } from '../x-element-next.js'; + +// Test basic property inheritance +class ParentElement extends XElement { + static { + [_init_parentProp, _init_sharedProp, _initProto] = _applyDecs(this, [[_parentPropDecs, 1, "parentProp"], [_sharedPropDecs, 1, "sharedProp"]], [], 0, void 0, XElement).e; + } + #A = (_initProto(this), _init_parentProp(this)); + get [(_parentPropDecs = property({ + type: String, + initial: 'parent-value' + }), _sharedPropDecs = property({ + type: Number, + initial: 42 + }), "parentProp")]() { + return this.#A; + } + set parentProp(v) { + this.#A = v; + } + #B = _init_sharedProp(this); + get sharedProp() { + return this.#B; + } + set sharedProp(v) { + this.#B = v; + } + static template(host) { + return html`
${host.parentProp}-${host.sharedProp}
`; + } +} +class ChildElement extends ParentElement { + static { + [_init_childProp, _init_sharedProp2, _initProto2] = _applyDecs(this, [[_childPropDecs, 1, "childProp"], [_sharedPropDecs2, 1, "sharedProp"]], [], 0, void 0, ParentElement).e; + } + #A = (_initProto2(this), _init_childProp(this)); // Override parent property with different configuration + get [(_childPropDecs = property({ + type: String, + initial: 'child-value' + }), _sharedPropDecs2 = property({ + type: Number, + initial: 100 + }), "childProp")]() { + return this.#A; + } + set childProp(v) { + this.#A = v; + } + #B = _init_sharedProp2(this); + get sharedProp() { + return this.#B; + } + set sharedProp(v) { + this.#B = v; + } + static template(host) { + return html`
${host.parentProp}-${host.childProp}-${host.sharedProp}
`; + } +} + +// Test listener inheritance +class ParentWithListener extends XElement { + static { + [_init_parentClicks, _initProto3, _initStatic] = _applyDecs(this, [[_onParentEventDecs, 10, "onParentEvent"], [_parentClicksDecs, 1, "parentClicks"]], [], 0, void 0, XElement).e; + _initStatic(this); + } + #A = (_initProto3(this), _init_parentClicks(this)); + get [(_parentClicksDecs = property({ + type: Number, + initial: 0 + }), _onParentEventDecs = listener('parent-event'), "parentClicks")]() { + return this.#A; + } + set parentClicks(v) { + this.#A = v; + } + static onParentEvent(host) { + host.parentClicks++; + } + static template(host) { + return html`
parent: ${host.parentClicks}
`; + } +} +class ChildWithListener extends ParentWithListener { + static { + [_init_childClicks, _initProto4, _initStatic2] = _applyDecs(this, [[_onChildEventDecs, 10, "onChildEvent"], [_childClicksDecs, 1, "childClicks"]], [], 0, void 0, ParentWithListener).e; + _initStatic2(this); + } + #A = (_initProto4(this), _init_childClicks(this)); + get [(_childClicksDecs = property({ + type: Number, + initial: 0 + }), _onChildEventDecs = listener('child-event'), "childClicks")]() { + return this.#A; + } + set childClicks(v) { + this.#A = v; + } + static onChildEvent(host) { + host.childClicks++; + } + static template(host) { + return html`
parent: ${host.parentClicks}, child: ${host.childClicks}
`; + } +} + +// Test multi-level inheritance +class GrandparentLevel extends XElement { + static { + [_init_level, _init_generation, _initProto5] = _applyDecs(this, [[_levelDecs, 1, "level"], [_generationDecs, 1, "generation"]], [], 0, void 0, XElement).e; + } + #A = (_initProto5(this), _init_level(this)); + get [(_levelDecs = property({ + type: String, + initial: 'grandparent' + }), _generationDecs = property({ + type: Number, + initial: 1 + }), "level")]() { + return this.#A; + } + set level(v) { + this.#A = v; + } + #B = _init_generation(this); + get generation() { + return this.#B; + } + set generation(v) { + this.#B = v; + } +} +class ParentLevel extends GrandparentLevel { + static { + [_init_level2, _init_generation2, _initProto6] = _applyDecs(this, [[_levelDecs2, 1, "level"], [_generationDecs2, 1, "generation"]], [], 0, void 0, GrandparentLevel).e; + } + #A = (_initProto6(this), _init_level2(this)); + get [(_levelDecs2 = property({ + type: String, + initial: 'parent' + }), _generationDecs2 = property({ + type: Number, + initial: 2 + }), "level")]() { + return this.#A; + } + set level(v) { + this.#A = v; + } + #B = _init_generation2(this); + get generation() { + return this.#B; + } + set generation(v) { + this.#B = v; + } +} +class ChildLevel extends ParentLevel { + static { + [_init_level3, _init_generation3, _initProto7] = _applyDecs(this, [[_levelDecs3, 1, "level"], [_generationDecs3, 1, "generation"]], [], 0, void 0, ParentLevel).e; + } + #A = (_initProto7(this), _init_level3(this)); + get [(_levelDecs3 = property({ + type: String, + initial: 'child' + }), _generationDecs3 = property({ + type: Number, + initial: 3 + }), "level")]() { + return this.#A; + } + set level(v) { + this.#A = v; + } + #B = _init_generation3(this); + get generation() { + return this.#B; + } + set generation(v) { + this.#B = v; + } +} + +// Test private property inheritance +// class ParentWithPrivate extends XElement { +// @property({ type: String, initial: 'public-parent' }) +// accessor publicProp; + +// @property({ type: String, initial: 'private-parent' }) +// accessor #privateProp; + +// getPrivate() { +// return this.#privateProp; +// } + +// static template(host) { +// return html`
${host.publicProp}
`; +// } +// } + +// class ChildWithPrivate extends ParentWithPrivate { +// @property({ type: String, initial: 'public-child' }) +// accessor publicProp; + +// // Child can have its own private property with same name - no collision! +// @property({ type: String, initial: 'private-child' }) +// accessor #privateProp; + +// getChildPrivate() { +// return this.#privateProp; +// } + +// static template(host) { +// return html`
${host.publicProp}
`; +// } +// } + +customElements.define('test-parent-element', ParentElement); +customElements.define('test-child-element', ChildElement); +customElements.define('test-parent-with-listener', ParentWithListener); +customElements.define('test-child-with-listener', ChildWithListener); +customElements.define('test-grandparent-level', GrandparentLevel); +customElements.define('test-parent-level', ParentLevel); +customElements.define('test-child-level', ChildLevel); +// TODO: Babel doesn't support decorators on private accessors yet +// customElements.define('test-parent-with-private', ParentWithPrivate); +// customElements.define('test-child-with-private', ChildWithPrivate); + +it('child inherits parent properties', () => { + const child = document.createElement('test-child-element'); + document.body.append(child); + // Child should have both parent and child properties + assert(child.parentProp === 'parent-value', 'has parent property'); + assert(child.childProp === 'child-value', 'has child property'); + child.remove(); +}); +it('child can override parent properties', () => { + const child = document.createElement('test-child-element'); + document.body.append(child); + // Child overrides sharedProp with initial value of 100 instead of 42 + assert(child.sharedProp === 100, 'child overrides parent property'); + child.remove(); +}); +it('parent properties remain independent', () => { + const parent = document.createElement('test-parent-element'); + document.body.append(parent); + // Parent should not be affected by child's override + assert(parent.sharedProp === 42, 'parent property unchanged'); + assert(parent.childProp === undefined, 'parent does not have child property'); + parent.remove(); +}); +it('child inherits parent template behavior', () => { + const child = document.createElement('test-child-element'); + document.body.append(child); + const text = child.shadowRoot.textContent; + assert(text === 'parent-value-child-value-100', 'child renders with all properties'); + child.remove(); +}); +it('child inherits parent listeners', () => { + const child = document.createElement('test-child-with-listener'); + document.body.append(child); + + // Child should respond to both parent and child events + assert(child.parentClicks === 0, 'parent clicks starts at 0'); + assert(child.childClicks === 0, 'child clicks starts at 0'); + + // Events must be dispatched from within shadow root since listeners attach there + child.shadowRoot.dispatchEvent(new CustomEvent('parent-event', { + bubbles: true + })); + assert(child.parentClicks === 1, 'parent listener works in child'); + child.shadowRoot.dispatchEvent(new CustomEvent('child-event', { + bubbles: true + })); + assert(child.childClicks === 1, 'child listener works'); + child.remove(); +}); +it('parent listeners remain independent', () => { + const parent = document.createElement('test-parent-with-listener'); + document.body.append(parent); + + // Events must be dispatched from within shadow root since listeners attach there + parent.shadowRoot.dispatchEvent(new CustomEvent('parent-event', { + bubbles: true + })); + assert(parent.parentClicks === 1, 'parent listener works'); + + // Parent should not respond to child-only events + parent.shadowRoot.dispatchEvent(new CustomEvent('child-event', { + bubbles: true + })); + assert(parent.childClicks === undefined, 'parent does not have child listener'); + parent.remove(); +}); +it('multi-level inheritance works (grandparent → parent → child)', () => { + const grandparent = document.createElement('test-grandparent-level'); + const parent = document.createElement('test-parent-level'); + const child = document.createElement('test-child-level'); + document.body.append(grandparent, parent, child); + assert(grandparent.level === 'grandparent', 'grandparent has correct level'); + assert(grandparent.generation === 1, 'grandparent has correct generation'); + assert(parent.level === 'parent', 'parent overrides level'); + assert(parent.generation === 2, 'parent overrides generation'); + assert(child.level === 'child', 'child overrides level'); + assert(child.generation === 3, 'child overrides generation'); + grandparent.remove(); + parent.remove(); + child.remove(); +}); +it.skip('private properties do not collide across inheritance', () => { + const parent = document.createElement('test-parent-with-private'); + const child = document.createElement('test-child-with-private'); + document.body.append(parent, child); + + // Each class has its own private #privateProp with different values + assert(parent.getPrivate() === 'private-parent', 'parent has its private value'); + assert(child.getPrivate() === 'private-parent', 'child inherits parent getter'); + assert(child.getChildPrivate() === 'private-child', 'child has its own private value'); + + // Public properties override correctly + assert(parent.publicProp === 'public-parent', 'parent public prop'); + assert(child.publicProp === 'public-child', 'child overrides public prop'); + parent.remove(); + child.remove(); +}); +it('property modifications do not affect parent class', () => { + const parent = document.createElement('test-parent-element'); + const child = document.createElement('test-child-element'); + document.body.append(parent, child); + + // Modify child instance + child.parentProp = 'modified'; + child.sharedProp = 999; + + // Parent instance should be unaffected + assert(parent.parentProp === 'parent-value', 'parent instance unchanged'); + assert(parent.sharedProp === 42, 'parent instance unchanged'); + + // Create new parent to verify class definition unchanged + const parent2 = document.createElement('test-parent-element'); + document.body.append(parent2); + assert(parent2.parentProp === 'parent-value', 'parent class definition unchanged'); + assert(parent2.sharedProp === 42, 'parent class definition unchanged'); + parent.remove(); + child.remove(); + parent2.remove(); +}); +it('out-of-order analysis (child analyzed before parent)', () => { + let _initProto8, _parentValueDecs, _init_parentValue, _sharedValueDecs, _init_sharedValue, _initProto9, _childValueDecs, _init_childValue, _sharedValueDecs2, _init_sharedValue2; + // Define new parent and child classes inline to ensure fresh analysis + class OutOfOrderParent extends XElement { + static { + [_init_parentValue, _init_sharedValue, _initProto8] = _applyDecs(this, [[_parentValueDecs, 1, "parentValue"], [_sharedValueDecs, 1, "sharedValue"]], [], 0, void 0, XElement).e; + } + #A = (_initProto8(this), _init_parentValue(this)); + get [(_parentValueDecs = property({ + type: String, + initial: 'parent-ooo' + }), _sharedValueDecs = property({ + type: Number, + initial: 10 + }), "parentValue")]() { + return this.#A; + } + set parentValue(v) { + this.#A = v; + } + #B = _init_sharedValue(this); + get sharedValue() { + return this.#B; + } + set sharedValue(v) { + this.#B = v; + } + } + class OutOfOrderChild extends OutOfOrderParent { + static { + [_init_childValue, _init_sharedValue2, _initProto9] = _applyDecs(this, [[_childValueDecs, 1, "childValue"], [_sharedValueDecs2, 1, "sharedValue"]], [], 0, void 0, OutOfOrderParent).e; + } + #A = (_initProto9(this), _init_childValue(this)); + get [(_childValueDecs = property({ + type: String, + initial: 'child-ooo' + }), _sharedValueDecs2 = property({ + type: Number, + initial: 20 + }), "childValue")]() { + return this.#A; + } + set childValue(v) { + this.#A = v; + } + #B = _init_sharedValue2(this); + get sharedValue() { + return this.#B; + } + set sharedValue(v) { + this.#B = v; + } + } + customElements.define('test-ooo-parent', OutOfOrderParent); + customElements.define('test-ooo-child', OutOfOrderChild); + + // Create child FIRST - this triggers analysis of child, which should + // automatically trigger parent analysis first to ensure proper inheritance + const child = document.createElement('test-ooo-child'); + document.body.append(child); + + // Verify child has correct values (would fail if parent wasn't analyzed first) + assert(child.parentValue === 'parent-ooo', 'child inherits parent property'); + assert(child.childValue === 'child-ooo', 'child has its own property'); + assert(child.sharedValue === 20, 'child overrides parent property'); + + // Now create parent and verify it's unaffected by child + const parent = document.createElement('test-ooo-parent'); + document.body.append(parent); + assert(parent.parentValue === 'parent-ooo', 'parent property correct'); + assert(parent.sharedValue === 10, 'parent property not affected by child'); + assert(parent.childValue === undefined, 'parent does not have child property'); + child.remove(); + parent.remove(); +}); +it('parent and child both listen to same event type', () => { + let _initProto0, _initStatic3, _parentCountDecs, _init_parentCount, _onParentSharedDecs, _initProto1, _initStatic4, _childCountDecs, _init_childCount, _onChildSharedDecs; + // Parent and child each have different methods listening to same event type + class ParentMultiListener extends XElement { + static { + [_init_parentCount, _initProto0, _initStatic3] = _applyDecs(this, [[_onParentSharedDecs, 10, "onParentShared"], [_parentCountDecs, 1, "parentCount"]], [], 0, void 0, XElement).e; + _initStatic3(this); + } + #A = (_initProto0(this), _init_parentCount(this)); + get [(_parentCountDecs = property({ + type: Number, + initial: 0 + }), _onParentSharedDecs = listener('shared-event'), "parentCount")]() { + return this.#A; + } + set parentCount(v) { + this.#A = v; + } + static onParentShared(host) { + host.parentCount++; + } + static template(host) { + return html`
parent: ${host.parentCount}
`; + } + } + class ChildMultiListener extends ParentMultiListener { + static { + [_init_childCount, _initProto1, _initStatic4] = _applyDecs(this, [[_onChildSharedDecs, 10, "onChildShared"], [_childCountDecs, 1, "childCount"]], [], 0, void 0, ParentMultiListener).e; + _initStatic4(this); + } + #A = (_initProto1(this), _init_childCount(this)); + get [(_childCountDecs = property({ + type: Number, + initial: 0 + }), _onChildSharedDecs = listener('shared-event'), "childCount")]() { + return this.#A; + } + set childCount(v) { + this.#A = v; + } + static onChildShared(host) { + host.childCount++; + } + static template(host) { + return html`
parent: ${host.parentCount}, child: ${host.childCount}
`; + } + } + customElements.define('test-parent-multi', ParentMultiListener); + customElements.define('test-child-multi', ChildMultiListener); + const child = document.createElement('test-child-multi'); + document.body.append(child); + assert(child.parentCount === 0, 'parent count starts at 0'); + assert(child.childCount === 0, 'child count starts at 0'); + + // Dispatch shared event - both parent and child listeners should fire + child.shadowRoot.dispatchEvent(new CustomEvent('shared-event', { + bubbles: true + })); + assert(child.parentCount === 1, 'parent listener fired'); + assert(child.childCount === 1, 'child listener fired'); + + // Fire again - both should increment + child.shadowRoot.dispatchEvent(new CustomEvent('shared-event', { + bubbles: true + })); + assert(child.parentCount === 2, 'parent listener fired again'); + assert(child.childCount === 2, 'child listener fired again'); + + // Verify parent instance only has parent listener + const parent = document.createElement('test-parent-multi'); + document.body.append(parent); + parent.shadowRoot.dispatchEvent(new CustomEvent('shared-event', { + bubbles: true + })); + assert(parent.parentCount === 1, 'parent listener works on parent instance'); + assert(parent.childCount === undefined, 'parent instance has no child listener'); + child.remove(); + parent.remove(); +}); +it('child overrides parent listener with same method name', () => { + let _initProto10, _initStatic5, _parentClicksDecs2, _init_parentClicks2, _onClickDecs, _initProto11, _initStatic6, _childClicksDecs2, _init_childClicks2, _onClickDecs2; + // When child redefines a method with the same name, only child's listener fires + class ParentWithMethod extends XElement { + static { + [_init_parentClicks2, _initProto10, _initStatic5] = _applyDecs(this, [[_onClickDecs, 10, "onClick"], [_parentClicksDecs2, 1, "parentClicks"]], [], 0, void 0, XElement).e; + _initStatic5(this); + } + #A = (_initProto10(this), _init_parentClicks2(this)); + get [(_parentClicksDecs2 = property({ + type: Number, + initial: 0 + }), _onClickDecs = listener('click'), "parentClicks")]() { + return this.#A; + } + set parentClicks(v) { + this.#A = v; + } + static onClick(host) { + host.parentClicks++; + } + static template(host) { + return html`
parent: ${host.parentClicks}
`; + } + } + class ChildOverridesMethod extends ParentWithMethod { + static { + [_init_childClicks2, _initProto11, _initStatic6] = _applyDecs(this, [[_onClickDecs2, 10, "onClick"], [_childClicksDecs2, 1, "childClicks"]], [], 0, void 0, ParentWithMethod).e; + _initStatic6(this); + } + #A = (_initProto11(this), _init_childClicks2(this)); + get [(_childClicksDecs2 = property({ + type: Number, + initial: 0 + }), _onClickDecs2 = listener('click'), "childClicks")]() { + return this.#A; + } + set childClicks(v) { + this.#A = v; + } + static onClick(host) { + // Same method name as parent - should override + host.childClicks++; + } + static template(host) { + return html`
parent: ${host.parentClicks}, child: ${host.childClicks}
`; + } + } + customElements.define('test-parent-with-method', ParentWithMethod); + customElements.define('test-child-overrides-method', ChildOverridesMethod); + const child = document.createElement('test-child-overrides-method'); + document.body.append(child); + assert(child.parentClicks === 0, 'parent clicks starts at 0'); + assert(child.childClicks === 0, 'child clicks starts at 0'); + + // Dispatch click event - only child's onClick should fire + child.shadowRoot.dispatchEvent(new CustomEvent('click', { + bubbles: true + })); + assert(child.parentClicks === 0, 'parent listener did not fire (overridden by child)'); + assert(child.childClicks === 1, 'child listener fired'); + + // Verify parent instance uses parent's onClick + const parent = document.createElement('test-parent-with-method'); + document.body.append(parent); + parent.shadowRoot.dispatchEvent(new CustomEvent('click', { + bubbles: true + })); + assert(parent.parentClicks === 1, 'parent listener works on parent instance'); + assert(parent.childClicks === undefined, 'parent instance has no child property'); + child.remove(); + parent.remove(); +}); +it('plain class without decorators (missing metadata link) works correctly', () => { + let _initProto12, _basePropDecs, _init_baseProp, _generationDecs4, _init_generation4, _initProto13, _childPropDecs2, _init_childProp2, _generationDecs5, _init_generation5; + // Test that a class without decorators in the middle of the inheritance chain + // works correctly and doesn't have Symbol.metadata polluted onto it + + class DecoratedBase extends XElement { + static { + [_init_baseProp, _init_generation4, _initProto12] = _applyDecs(this, [[_basePropDecs, 1, "baseProp"], [_generationDecs4, 1, "generation"]], [], 0, void 0, XElement).e; + } + #A = (_initProto12(this), _init_baseProp(this)); + get [(_basePropDecs = property({ + type: String, + initial: 'base-value' + }), _generationDecs4 = property({ + type: Number, + initial: 1 + }), "baseProp")]() { + return this.#A; + } + set baseProp(v) { + this.#A = v; + } + #B = _init_generation4(this); + get generation() { + return this.#B; + } + set generation(v) { + this.#B = v; + } + } + + // Plain class with NO decorators - this is the "missing link" + class PlainMiddle extends DecoratedBase { + // No decorators! Just plain class extending decorated base + } + class DecoratedChild extends PlainMiddle { + static { + [_init_childProp2, _init_generation5, _initProto13] = _applyDecs(this, [[_childPropDecs2, 1, "childProp"], [_generationDecs5, 1, "generation"]], [], 0, void 0, PlainMiddle).e; + } + #A = (_initProto13(this), _init_childProp2(this)); + get [(_childPropDecs2 = property({ + type: String, + initial: 'child-value' + }), _generationDecs5 = property({ + type: Number, + initial: 3 + }), "childProp")]() { + return this.#A; + } + set childProp(v) { + this.#A = v; + } + #B = _init_generation5(this); + get generation() { + return this.#B; + } + set generation(v) { + this.#B = v; + } + } + customElements.define('test-decorated-base-link', DecoratedBase); + customElements.define('test-plain-middle-link', PlainMiddle); + customElements.define('test-decorated-child-link', DecoratedChild); + + // CRITICAL: Verify PlainMiddle doesn't have Symbol.metadata as OWN property + // (it might inherit from parent via prototype chain, but shouldn't have its own) + assert(!Object.hasOwn(PlainMiddle, Symbol.metadata), 'plain class has no own Symbol.metadata property'); + + // Verify DecoratedBase and DecoratedChild DO have Symbol.metadata (from decorators) + assert(DecoratedBase[Symbol.metadata] !== undefined, 'decorated base has Symbol.metadata'); + assert(DecoratedChild[Symbol.metadata] !== undefined, 'decorated child has Symbol.metadata'); + + // Create instances and verify inheritance still works correctly + const base = document.createElement('test-decorated-base-link'); + document.body.append(base); + assert(base.baseProp === 'base-value', 'base has baseProp'); + assert(base.generation === 1, 'base has generation 1'); + assert(base.childProp === undefined, 'base has no child property'); + const middle = document.createElement('test-plain-middle-link'); + document.body.append(middle); + assert(middle.baseProp === 'base-value', 'middle inherits baseProp from base'); + assert(middle.generation === 1, 'middle inherits generation from base'); + assert(middle.childProp === undefined, 'middle has no child property'); + const child = document.createElement('test-decorated-child-link'); + document.body.append(child); + assert(child.baseProp === 'base-value', 'child inherits baseProp through plain middle'); + assert(child.childProp === 'child-value', 'child has childProp'); + assert(child.generation === 3, 'child overrides generation'); + + // Verify that modifications to child don't affect middle or base + child.baseProp = 'modified'; + assert(middle.baseProp === 'base-value', 'middle unchanged after child modification'); + assert(base.baseProp === 'base-value', 'base unchanged after child modification'); + base.remove(); + middle.remove(); + child.remove(); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["assert","it","XElement","property","listener","html","ParentElement","_init_parentProp","_init_sharedProp","_initProto","_applyDecs","_parentPropDecs","_sharedPropDecs","e","A","type","String","initial","Number","parentProp","v","B","sharedProp","template","host","ChildElement","_init_childProp","_init_sharedProp2","_initProto2","_childPropDecs","_sharedPropDecs2","childProp","ParentWithListener","_init_parentClicks","_initProto3","_initStatic","_onParentEventDecs","_parentClicksDecs","parentClicks","onParentEvent","ChildWithListener","_init_childClicks","_initProto4","_initStatic2","_onChildEventDecs","_childClicksDecs","childClicks","onChildEvent","GrandparentLevel","_init_level","_init_generation","_initProto5","_levelDecs","_generationDecs","level","generation","ParentLevel","_init_level2","_init_generation2","_initProto6","_levelDecs2","_generationDecs2","ChildLevel","_init_level3","_init_generation3","_initProto7","_levelDecs3","_generationDecs3","customElements","define","child","document","createElement","body","append","remove","parent","undefined","text","shadowRoot","textContent","dispatchEvent","CustomEvent","bubbles","grandparent","skip","getPrivate","getChildPrivate","publicProp","parent2","_initProto8","_parentValueDecs","_init_parentValue","_sharedValueDecs","_init_sharedValue","_initProto9","_childValueDecs","_init_childValue","_sharedValueDecs2","_init_sharedValue2","OutOfOrderParent","parentValue","sharedValue","OutOfOrderChild","childValue","_initProto0","_initStatic3","_parentCountDecs","_init_parentCount","_onParentSharedDecs","_initProto1","_initStatic4","_childCountDecs","_init_childCount","_onChildSharedDecs","ParentMultiListener","parentCount","onParentShared","ChildMultiListener","childCount","onChildShared","_initProto10","_initStatic5","_parentClicksDecs2","_init_parentClicks2","_onClickDecs","_initProto11","_initStatic6","_childClicksDecs2","_init_childClicks2","_onClickDecs2","ParentWithMethod","onClick","ChildOverridesMethod","_initProto12","_basePropDecs","_init_baseProp","_generationDecs4","_init_generation4","_initProto13","_childPropDecs2","_init_childProp2","_generationDecs5","_init_generation5","DecoratedBase","baseProp","PlainMiddle","DecoratedChild","Object","hasOwn","Symbol","metadata","base","middle"],"sources":["test-inheritance.src.js"],"sourcesContent":["import { assert, it } from '@netflix/x-test/x-test.js';\nimport { XElement, property, listener, html } from '../x-element-next.js';\n\n// Test basic property inheritance\nclass ParentElement extends XElement {\n  @property({ type: String, initial: 'parent-value' })\n  accessor parentProp;\n\n  @property({ type: Number, initial: 42 })\n  accessor sharedProp;\n\n  static template(host) {\n    return html`<div>${host.parentProp}-${host.sharedProp}</div>`;\n  }\n}\n\nclass ChildElement extends ParentElement {\n  @property({ type: String, initial: 'child-value' })\n  accessor childProp;\n\n  // Override parent property with different configuration\n  @property({ type: Number, initial: 100 })\n  accessor sharedProp;\n\n  static template(host) {\n    return html`<div>${host.parentProp}-${host.childProp}-${host.sharedProp}</div>`;\n  }\n}\n\n// Test listener inheritance\nclass ParentWithListener extends XElement {\n  @property({ type: Number, initial: 0 })\n  accessor parentClicks;\n\n  @listener('parent-event')\n  static onParentEvent(host) {\n    host.parentClicks++;\n  }\n\n  static template(host) {\n    return html`<div>parent: ${host.parentClicks}</div>`;\n  }\n}\n\nclass ChildWithListener extends ParentWithListener {\n  @property({ type: Number, initial: 0 })\n  accessor childClicks;\n\n  @listener('child-event')\n  static onChildEvent(host) {\n    host.childClicks++;\n  }\n\n  static template(host) {\n    return html`<div>parent: ${host.parentClicks}, child: ${host.childClicks}</div>`;\n  }\n}\n\n// Test multi-level inheritance\nclass GrandparentLevel extends XElement {\n  @property({ type: String, initial: 'grandparent' })\n  accessor level;\n\n  @property({ type: Number, initial: 1 })\n  accessor generation;\n}\n\nclass ParentLevel extends GrandparentLevel {\n  @property({ type: String, initial: 'parent' })\n  accessor level;\n\n  @property({ type: Number, initial: 2 })\n  accessor generation;\n}\n\nclass ChildLevel extends ParentLevel {\n  @property({ type: String, initial: 'child' })\n  accessor level;\n\n  @property({ type: Number, initial: 3 })\n  accessor generation;\n}\n\n// Test private property inheritance\n// class ParentWithPrivate extends XElement {\n//   @property({ type: String, initial: 'public-parent' })\n//   accessor publicProp;\n\n//   @property({ type: String, initial: 'private-parent' })\n//   accessor #privateProp;\n\n//   getPrivate() {\n//     return this.#privateProp;\n//   }\n\n//   static template(host) {\n//     return html`<div>${host.publicProp}</div>`;\n//   }\n// }\n\n// class ChildWithPrivate extends ParentWithPrivate {\n//   @property({ type: String, initial: 'public-child' })\n//   accessor publicProp;\n\n//   // Child can have its own private property with same name - no collision!\n//   @property({ type: String, initial: 'private-child' })\n//   accessor #privateProp;\n\n//   getChildPrivate() {\n//     return this.#privateProp;\n//   }\n\n//   static template(host) {\n//     return html`<div>${host.publicProp}</div>`;\n//   }\n// }\n\ncustomElements.define('test-parent-element', ParentElement);\ncustomElements.define('test-child-element', ChildElement);\ncustomElements.define('test-parent-with-listener', ParentWithListener);\ncustomElements.define('test-child-with-listener', ChildWithListener);\ncustomElements.define('test-grandparent-level', GrandparentLevel);\ncustomElements.define('test-parent-level', ParentLevel);\ncustomElements.define('test-child-level', ChildLevel);\n// TODO: Babel doesn't support decorators on private accessors yet\n// customElements.define('test-parent-with-private', ParentWithPrivate);\n// customElements.define('test-child-with-private', ChildWithPrivate);\n\nit('child inherits parent properties', () => {\n  const child = document.createElement('test-child-element');\n  document.body.append(child);\n  // Child should have both parent and child properties\n  assert(child.parentProp === 'parent-value', 'has parent property');\n  assert(child.childProp === 'child-value', 'has child property');\n  child.remove();\n});\n\nit('child can override parent properties', () => {\n  const child = document.createElement('test-child-element');\n  document.body.append(child);\n  // Child overrides sharedProp with initial value of 100 instead of 42\n  assert(child.sharedProp === 100, 'child overrides parent property');\n  child.remove();\n});\n\nit('parent properties remain independent', () => {\n  const parent = document.createElement('test-parent-element');\n  document.body.append(parent);\n  // Parent should not be affected by child's override\n  assert(parent.sharedProp === 42, 'parent property unchanged');\n  assert(parent.childProp === undefined, 'parent does not have child property');\n  parent.remove();\n});\n\nit('child inherits parent template behavior', () => {\n  const child = document.createElement('test-child-element');\n  document.body.append(child);\n  const text = child.shadowRoot.textContent;\n  assert(text === 'parent-value-child-value-100', 'child renders with all properties');\n  child.remove();\n});\n\nit('child inherits parent listeners', () => {\n  const child = document.createElement('test-child-with-listener');\n  document.body.append(child);\n\n  // Child should respond to both parent and child events\n  assert(child.parentClicks === 0, 'parent clicks starts at 0');\n  assert(child.childClicks === 0, 'child clicks starts at 0');\n\n  // Events must be dispatched from within shadow root since listeners attach there\n  child.shadowRoot.dispatchEvent(new CustomEvent('parent-event', { bubbles: true }));\n  assert(child.parentClicks === 1, 'parent listener works in child');\n\n  child.shadowRoot.dispatchEvent(new CustomEvent('child-event', { bubbles: true }));\n  assert(child.childClicks === 1, 'child listener works');\n\n  child.remove();\n});\n\nit('parent listeners remain independent', () => {\n  const parent = document.createElement('test-parent-with-listener');\n  document.body.append(parent);\n\n  // Events must be dispatched from within shadow root since listeners attach there\n  parent.shadowRoot.dispatchEvent(new CustomEvent('parent-event', { bubbles: true }));\n  assert(parent.parentClicks === 1, 'parent listener works');\n\n  // Parent should not respond to child-only events\n  parent.shadowRoot.dispatchEvent(new CustomEvent('child-event', { bubbles: true }));\n  assert(parent.childClicks === undefined, 'parent does not have child listener');\n\n  parent.remove();\n});\n\nit('multi-level inheritance works (grandparent → parent → child)', () => {\n  const grandparent = document.createElement('test-grandparent-level');\n  const parent = document.createElement('test-parent-level');\n  const child = document.createElement('test-child-level');\n\n  document.body.append(grandparent, parent, child);\n\n  assert(grandparent.level === 'grandparent', 'grandparent has correct level');\n  assert(grandparent.generation === 1, 'grandparent has correct generation');\n\n  assert(parent.level === 'parent', 'parent overrides level');\n  assert(parent.generation === 2, 'parent overrides generation');\n\n  assert(child.level === 'child', 'child overrides level');\n  assert(child.generation === 3, 'child overrides generation');\n\n  grandparent.remove();\n  parent.remove();\n  child.remove();\n});\n\nit.skip('private properties do not collide across inheritance', () => {\n  const parent = document.createElement('test-parent-with-private');\n  const child = document.createElement('test-child-with-private');\n\n  document.body.append(parent, child);\n\n  // Each class has its own private #privateProp with different values\n  assert(parent.getPrivate() === 'private-parent', 'parent has its private value');\n  assert(child.getPrivate() === 'private-parent', 'child inherits parent getter');\n  assert(child.getChildPrivate() === 'private-child', 'child has its own private value');\n\n  // Public properties override correctly\n  assert(parent.publicProp === 'public-parent', 'parent public prop');\n  assert(child.publicProp === 'public-child', 'child overrides public prop');\n\n  parent.remove();\n  child.remove();\n});\n\nit('property modifications do not affect parent class', () => {\n  const parent = document.createElement('test-parent-element');\n  const child = document.createElement('test-child-element');\n\n  document.body.append(parent, child);\n\n  // Modify child instance\n  child.parentProp = 'modified';\n  child.sharedProp = 999;\n\n  // Parent instance should be unaffected\n  assert(parent.parentProp === 'parent-value', 'parent instance unchanged');\n  assert(parent.sharedProp === 42, 'parent instance unchanged');\n\n  // Create new parent to verify class definition unchanged\n  const parent2 = document.createElement('test-parent-element');\n  document.body.append(parent2);\n  assert(parent2.parentProp === 'parent-value', 'parent class definition unchanged');\n  assert(parent2.sharedProp === 42, 'parent class definition unchanged');\n\n  parent.remove();\n  child.remove();\n  parent2.remove();\n});\n\nit('out-of-order analysis (child analyzed before parent)', () => {\n  // Define new parent and child classes inline to ensure fresh analysis\n  class OutOfOrderParent extends XElement {\n    @property({ type: String, initial: 'parent-ooo' })\n    accessor parentValue;\n\n    @property({ type: Number, initial: 10 })\n    accessor sharedValue;\n  }\n\n  class OutOfOrderChild extends OutOfOrderParent {\n    @property({ type: String, initial: 'child-ooo' })\n    accessor childValue;\n\n    @property({ type: Number, initial: 20 })\n    accessor sharedValue;\n  }\n\n  customElements.define('test-ooo-parent', OutOfOrderParent);\n  customElements.define('test-ooo-child', OutOfOrderChild);\n\n  // Create child FIRST - this triggers analysis of child, which should\n  // automatically trigger parent analysis first to ensure proper inheritance\n  const child = document.createElement('test-ooo-child');\n  document.body.append(child);\n\n  // Verify child has correct values (would fail if parent wasn't analyzed first)\n  assert(child.parentValue === 'parent-ooo', 'child inherits parent property');\n  assert(child.childValue === 'child-ooo', 'child has its own property');\n  assert(child.sharedValue === 20, 'child overrides parent property');\n\n  // Now create parent and verify it's unaffected by child\n  const parent = document.createElement('test-ooo-parent');\n  document.body.append(parent);\n\n  assert(parent.parentValue === 'parent-ooo', 'parent property correct');\n  assert(parent.sharedValue === 10, 'parent property not affected by child');\n  assert(parent.childValue === undefined, 'parent does not have child property');\n\n  child.remove();\n  parent.remove();\n});\n\nit('parent and child both listen to same event type', () => {\n  // Parent and child each have different methods listening to same event type\n  class ParentMultiListener extends XElement {\n    @property({ type: Number, initial: 0 })\n    accessor parentCount;\n\n    @listener('shared-event')\n    static onParentShared(host) {\n      host.parentCount++;\n    }\n\n    static template(host) {\n      return html`<div>parent: ${host.parentCount}</div>`;\n    }\n  }\n\n  class ChildMultiListener extends ParentMultiListener {\n    @property({ type: Number, initial: 0 })\n    accessor childCount;\n\n    @listener('shared-event')\n    static onChildShared(host) {\n      host.childCount++;\n    }\n\n    static template(host) {\n      return html`<div>parent: ${host.parentCount}, child: ${host.childCount}</div>`;\n    }\n  }\n\n  customElements.define('test-parent-multi', ParentMultiListener);\n  customElements.define('test-child-multi', ChildMultiListener);\n\n  const child = document.createElement('test-child-multi');\n  document.body.append(child);\n\n  assert(child.parentCount === 0, 'parent count starts at 0');\n  assert(child.childCount === 0, 'child count starts at 0');\n\n  // Dispatch shared event - both parent and child listeners should fire\n  child.shadowRoot.dispatchEvent(new CustomEvent('shared-event', { bubbles: true }));\n\n  assert(child.parentCount === 1, 'parent listener fired');\n  assert(child.childCount === 1, 'child listener fired');\n\n  // Fire again - both should increment\n  child.shadowRoot.dispatchEvent(new CustomEvent('shared-event', { bubbles: true }));\n\n  assert(child.parentCount === 2, 'parent listener fired again');\n  assert(child.childCount === 2, 'child listener fired again');\n\n  // Verify parent instance only has parent listener\n  const parent = document.createElement('test-parent-multi');\n  document.body.append(parent);\n\n  parent.shadowRoot.dispatchEvent(new CustomEvent('shared-event', { bubbles: true }));\n\n  assert(parent.parentCount === 1, 'parent listener works on parent instance');\n  assert(parent.childCount === undefined, 'parent instance has no child listener');\n\n  child.remove();\n  parent.remove();\n});\n\nit('child overrides parent listener with same method name', () => {\n  // When child redefines a method with the same name, only child's listener fires\n  class ParentWithMethod extends XElement {\n    @property({ type: Number, initial: 0 })\n    accessor parentClicks;\n\n    @listener('click')\n    static onClick(host) {\n      host.parentClicks++;\n    }\n\n    static template(host) {\n      return html`<div>parent: ${host.parentClicks}</div>`;\n    }\n  }\n\n  class ChildOverridesMethod extends ParentWithMethod {\n    @property({ type: Number, initial: 0 })\n    accessor childClicks;\n\n    @listener('click')\n    static onClick(host) {\n      // Same method name as parent - should override\n      host.childClicks++;\n    }\n\n    static template(host) {\n      return html`<div>parent: ${host.parentClicks}, child: ${host.childClicks}</div>`;\n    }\n  }\n\n  customElements.define('test-parent-with-method', ParentWithMethod);\n  customElements.define('test-child-overrides-method', ChildOverridesMethod);\n\n  const child = document.createElement('test-child-overrides-method');\n  document.body.append(child);\n\n  assert(child.parentClicks === 0, 'parent clicks starts at 0');\n  assert(child.childClicks === 0, 'child clicks starts at 0');\n\n  // Dispatch click event - only child's onClick should fire\n  child.shadowRoot.dispatchEvent(new CustomEvent('click', { bubbles: true }));\n\n  assert(child.parentClicks === 0, 'parent listener did not fire (overridden by child)');\n  assert(child.childClicks === 1, 'child listener fired');\n\n  // Verify parent instance uses parent's onClick\n  const parent = document.createElement('test-parent-with-method');\n  document.body.append(parent);\n\n  parent.shadowRoot.dispatchEvent(new CustomEvent('click', { bubbles: true }));\n\n  assert(parent.parentClicks === 1, 'parent listener works on parent instance');\n  assert(parent.childClicks === undefined, 'parent instance has no child property');\n\n  child.remove();\n  parent.remove();\n});\n\nit('plain class without decorators (missing metadata link) works correctly', () => {\n  // Test that a class without decorators in the middle of the inheritance chain\n  // works correctly and doesn't have Symbol.metadata polluted onto it\n\n  class DecoratedBase extends XElement {\n    @property({ type: String, initial: 'base-value' })\n    accessor baseProp;\n\n    @property({ type: Number, initial: 1 })\n    accessor generation;\n  }\n\n  // Plain class with NO decorators - this is the \"missing link\"\n  class PlainMiddle extends DecoratedBase {\n    // No decorators! Just plain class extending decorated base\n  }\n\n  class DecoratedChild extends PlainMiddle {\n    @property({ type: String, initial: 'child-value' })\n    accessor childProp;\n\n    @property({ type: Number, initial: 3 })\n    accessor generation;\n  }\n\n  customElements.define('test-decorated-base-link', DecoratedBase);\n  customElements.define('test-plain-middle-link', PlainMiddle);\n  customElements.define('test-decorated-child-link', DecoratedChild);\n\n  // CRITICAL: Verify PlainMiddle doesn't have Symbol.metadata as OWN property\n  // (it might inherit from parent via prototype chain, but shouldn't have its own)\n  assert(!Object.hasOwn(PlainMiddle, Symbol.metadata), 'plain class has no own Symbol.metadata property');\n\n  // Verify DecoratedBase and DecoratedChild DO have Symbol.metadata (from decorators)\n  assert(DecoratedBase[Symbol.metadata] !== undefined, 'decorated base has Symbol.metadata');\n  assert(DecoratedChild[Symbol.metadata] !== undefined, 'decorated child has Symbol.metadata');\n\n  // Create instances and verify inheritance still works correctly\n  const base = document.createElement('test-decorated-base-link');\n  document.body.append(base);\n\n  assert(base.baseProp === 'base-value', 'base has baseProp');\n  assert(base.generation === 1, 'base has generation 1');\n  assert(base.childProp === undefined, 'base has no child property');\n\n  const middle = document.createElement('test-plain-middle-link');\n  document.body.append(middle);\n\n  assert(middle.baseProp === 'base-value', 'middle inherits baseProp from base');\n  assert(middle.generation === 1, 'middle inherits generation from base');\n  assert(middle.childProp === undefined, 'middle has no child property');\n\n  const child = document.createElement('test-decorated-child-link');\n  document.body.append(child);\n\n  assert(child.baseProp === 'base-value', 'child inherits baseProp through plain middle');\n  assert(child.childProp === 'child-value', 'child has childProp');\n  assert(child.generation === 3, 'child overrides generation');\n\n  // Verify that modifications to child don't affect middle or base\n  child.baseProp = 'modified';\n  assert(middle.baseProp === 'base-value', 'middle unchanged after child modification');\n  assert(base.baseProp === 'base-value', 'base unchanged after child modification');\n\n  base.remove();\n  middle.remove();\n  child.remove();\n});\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/test-next/test-inheritance.src.js b/test-next/test-inheritance.src.js new file mode 100644 index 0000000..38b0195 --- /dev/null +++ b/test-next/test-inheritance.src.js @@ -0,0 +1,494 @@ +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, listener, html } from '../x-element-next.js'; + +// Test basic property inheritance +class ParentElement extends XElement { + @property({ type: String, initial: 'parent-value' }) + accessor parentProp; + + @property({ type: Number, initial: 42 }) + accessor sharedProp; + + static template(host) { + return html`
${host.parentProp}-${host.sharedProp}
`; + } +} + +class ChildElement extends ParentElement { + @property({ type: String, initial: 'child-value' }) + accessor childProp; + + // Override parent property with different configuration + @property({ type: Number, initial: 100 }) + accessor sharedProp; + + static template(host) { + return html`
${host.parentProp}-${host.childProp}-${host.sharedProp}
`; + } +} + +// Test listener inheritance +class ParentWithListener extends XElement { + @property({ type: Number, initial: 0 }) + accessor parentClicks; + + @listener('parent-event') + static onParentEvent(host) { + host.parentClicks++; + } + + static template(host) { + return html`
parent: ${host.parentClicks}
`; + } +} + +class ChildWithListener extends ParentWithListener { + @property({ type: Number, initial: 0 }) + accessor childClicks; + + @listener('child-event') + static onChildEvent(host) { + host.childClicks++; + } + + static template(host) { + return html`
parent: ${host.parentClicks}, child: ${host.childClicks}
`; + } +} + +// Test multi-level inheritance +class GrandparentLevel extends XElement { + @property({ type: String, initial: 'grandparent' }) + accessor level; + + @property({ type: Number, initial: 1 }) + accessor generation; +} + +class ParentLevel extends GrandparentLevel { + @property({ type: String, initial: 'parent' }) + accessor level; + + @property({ type: Number, initial: 2 }) + accessor generation; +} + +class ChildLevel extends ParentLevel { + @property({ type: String, initial: 'child' }) + accessor level; + + @property({ type: Number, initial: 3 }) + accessor generation; +} + +// Test private property inheritance +// class ParentWithPrivate extends XElement { +// @property({ type: String, initial: 'public-parent' }) +// accessor publicProp; + +// @property({ type: String, initial: 'private-parent' }) +// accessor #privateProp; + +// getPrivate() { +// return this.#privateProp; +// } + +// static template(host) { +// return html`
${host.publicProp}
`; +// } +// } + +// class ChildWithPrivate extends ParentWithPrivate { +// @property({ type: String, initial: 'public-child' }) +// accessor publicProp; + +// // Child can have its own private property with same name - no collision! +// @property({ type: String, initial: 'private-child' }) +// accessor #privateProp; + +// getChildPrivate() { +// return this.#privateProp; +// } + +// static template(host) { +// return html`
${host.publicProp}
`; +// } +// } + +customElements.define('test-parent-element', ParentElement); +customElements.define('test-child-element', ChildElement); +customElements.define('test-parent-with-listener', ParentWithListener); +customElements.define('test-child-with-listener', ChildWithListener); +customElements.define('test-grandparent-level', GrandparentLevel); +customElements.define('test-parent-level', ParentLevel); +customElements.define('test-child-level', ChildLevel); +// TODO: Babel doesn't support decorators on private accessors yet +// customElements.define('test-parent-with-private', ParentWithPrivate); +// customElements.define('test-child-with-private', ChildWithPrivate); + +it('child inherits parent properties', () => { + const child = document.createElement('test-child-element'); + document.body.append(child); + // Child should have both parent and child properties + assert(child.parentProp === 'parent-value', 'has parent property'); + assert(child.childProp === 'child-value', 'has child property'); + child.remove(); +}); + +it('child can override parent properties', () => { + const child = document.createElement('test-child-element'); + document.body.append(child); + // Child overrides sharedProp with initial value of 100 instead of 42 + assert(child.sharedProp === 100, 'child overrides parent property'); + child.remove(); +}); + +it('parent properties remain independent', () => { + const parent = document.createElement('test-parent-element'); + document.body.append(parent); + // Parent should not be affected by child's override + assert(parent.sharedProp === 42, 'parent property unchanged'); + assert(parent.childProp === undefined, 'parent does not have child property'); + parent.remove(); +}); + +it('child inherits parent template behavior', () => { + const child = document.createElement('test-child-element'); + document.body.append(child); + const text = child.shadowRoot.textContent; + assert(text === 'parent-value-child-value-100', 'child renders with all properties'); + child.remove(); +}); + +it('child inherits parent listeners', () => { + const child = document.createElement('test-child-with-listener'); + document.body.append(child); + + // Child should respond to both parent and child events + assert(child.parentClicks === 0, 'parent clicks starts at 0'); + assert(child.childClicks === 0, 'child clicks starts at 0'); + + // Events must be dispatched from within shadow root since listeners attach there + child.shadowRoot.dispatchEvent(new CustomEvent('parent-event', { bubbles: true })); + assert(child.parentClicks === 1, 'parent listener works in child'); + + child.shadowRoot.dispatchEvent(new CustomEvent('child-event', { bubbles: true })); + assert(child.childClicks === 1, 'child listener works'); + + child.remove(); +}); + +it('parent listeners remain independent', () => { + const parent = document.createElement('test-parent-with-listener'); + document.body.append(parent); + + // Events must be dispatched from within shadow root since listeners attach there + parent.shadowRoot.dispatchEvent(new CustomEvent('parent-event', { bubbles: true })); + assert(parent.parentClicks === 1, 'parent listener works'); + + // Parent should not respond to child-only events + parent.shadowRoot.dispatchEvent(new CustomEvent('child-event', { bubbles: true })); + assert(parent.childClicks === undefined, 'parent does not have child listener'); + + parent.remove(); +}); + +it('multi-level inheritance works (grandparent → parent → child)', () => { + const grandparent = document.createElement('test-grandparent-level'); + const parent = document.createElement('test-parent-level'); + const child = document.createElement('test-child-level'); + + document.body.append(grandparent, parent, child); + + assert(grandparent.level === 'grandparent', 'grandparent has correct level'); + assert(grandparent.generation === 1, 'grandparent has correct generation'); + + assert(parent.level === 'parent', 'parent overrides level'); + assert(parent.generation === 2, 'parent overrides generation'); + + assert(child.level === 'child', 'child overrides level'); + assert(child.generation === 3, 'child overrides generation'); + + grandparent.remove(); + parent.remove(); + child.remove(); +}); + +it.skip('private properties do not collide across inheritance', () => { + const parent = document.createElement('test-parent-with-private'); + const child = document.createElement('test-child-with-private'); + + document.body.append(parent, child); + + // Each class has its own private #privateProp with different values + assert(parent.getPrivate() === 'private-parent', 'parent has its private value'); + assert(child.getPrivate() === 'private-parent', 'child inherits parent getter'); + assert(child.getChildPrivate() === 'private-child', 'child has its own private value'); + + // Public properties override correctly + assert(parent.publicProp === 'public-parent', 'parent public prop'); + assert(child.publicProp === 'public-child', 'child overrides public prop'); + + parent.remove(); + child.remove(); +}); + +it('property modifications do not affect parent class', () => { + const parent = document.createElement('test-parent-element'); + const child = document.createElement('test-child-element'); + + document.body.append(parent, child); + + // Modify child instance + child.parentProp = 'modified'; + child.sharedProp = 999; + + // Parent instance should be unaffected + assert(parent.parentProp === 'parent-value', 'parent instance unchanged'); + assert(parent.sharedProp === 42, 'parent instance unchanged'); + + // Create new parent to verify class definition unchanged + const parent2 = document.createElement('test-parent-element'); + document.body.append(parent2); + assert(parent2.parentProp === 'parent-value', 'parent class definition unchanged'); + assert(parent2.sharedProp === 42, 'parent class definition unchanged'); + + parent.remove(); + child.remove(); + parent2.remove(); +}); + +it('out-of-order analysis (child analyzed before parent)', () => { + // Define new parent and child classes inline to ensure fresh analysis + class OutOfOrderParent extends XElement { + @property({ type: String, initial: 'parent-ooo' }) + accessor parentValue; + + @property({ type: Number, initial: 10 }) + accessor sharedValue; + } + + class OutOfOrderChild extends OutOfOrderParent { + @property({ type: String, initial: 'child-ooo' }) + accessor childValue; + + @property({ type: Number, initial: 20 }) + accessor sharedValue; + } + + customElements.define('test-ooo-parent', OutOfOrderParent); + customElements.define('test-ooo-child', OutOfOrderChild); + + // Create child FIRST - this triggers analysis of child, which should + // automatically trigger parent analysis first to ensure proper inheritance + const child = document.createElement('test-ooo-child'); + document.body.append(child); + + // Verify child has correct values (would fail if parent wasn't analyzed first) + assert(child.parentValue === 'parent-ooo', 'child inherits parent property'); + assert(child.childValue === 'child-ooo', 'child has its own property'); + assert(child.sharedValue === 20, 'child overrides parent property'); + + // Now create parent and verify it's unaffected by child + const parent = document.createElement('test-ooo-parent'); + document.body.append(parent); + + assert(parent.parentValue === 'parent-ooo', 'parent property correct'); + assert(parent.sharedValue === 10, 'parent property not affected by child'); + assert(parent.childValue === undefined, 'parent does not have child property'); + + child.remove(); + parent.remove(); +}); + +it('parent and child both listen to same event type', () => { + // Parent and child each have different methods listening to same event type + class ParentMultiListener extends XElement { + @property({ type: Number, initial: 0 }) + accessor parentCount; + + @listener('shared-event') + static onParentShared(host) { + host.parentCount++; + } + + static template(host) { + return html`
parent: ${host.parentCount}
`; + } + } + + class ChildMultiListener extends ParentMultiListener { + @property({ type: Number, initial: 0 }) + accessor childCount; + + @listener('shared-event') + static onChildShared(host) { + host.childCount++; + } + + static template(host) { + return html`
parent: ${host.parentCount}, child: ${host.childCount}
`; + } + } + + customElements.define('test-parent-multi', ParentMultiListener); + customElements.define('test-child-multi', ChildMultiListener); + + const child = document.createElement('test-child-multi'); + document.body.append(child); + + assert(child.parentCount === 0, 'parent count starts at 0'); + assert(child.childCount === 0, 'child count starts at 0'); + + // Dispatch shared event - both parent and child listeners should fire + child.shadowRoot.dispatchEvent(new CustomEvent('shared-event', { bubbles: true })); + + assert(child.parentCount === 1, 'parent listener fired'); + assert(child.childCount === 1, 'child listener fired'); + + // Fire again - both should increment + child.shadowRoot.dispatchEvent(new CustomEvent('shared-event', { bubbles: true })); + + assert(child.parentCount === 2, 'parent listener fired again'); + assert(child.childCount === 2, 'child listener fired again'); + + // Verify parent instance only has parent listener + const parent = document.createElement('test-parent-multi'); + document.body.append(parent); + + parent.shadowRoot.dispatchEvent(new CustomEvent('shared-event', { bubbles: true })); + + assert(parent.parentCount === 1, 'parent listener works on parent instance'); + assert(parent.childCount === undefined, 'parent instance has no child listener'); + + child.remove(); + parent.remove(); +}); + +it('child overrides parent listener with same method name', () => { + // When child redefines a method with the same name, only child's listener fires + class ParentWithMethod extends XElement { + @property({ type: Number, initial: 0 }) + accessor parentClicks; + + @listener('click') + static onClick(host) { + host.parentClicks++; + } + + static template(host) { + return html`
parent: ${host.parentClicks}
`; + } + } + + class ChildOverridesMethod extends ParentWithMethod { + @property({ type: Number, initial: 0 }) + accessor childClicks; + + @listener('click') + static onClick(host) { + // Same method name as parent - should override + host.childClicks++; + } + + static template(host) { + return html`
parent: ${host.parentClicks}, child: ${host.childClicks}
`; + } + } + + customElements.define('test-parent-with-method', ParentWithMethod); + customElements.define('test-child-overrides-method', ChildOverridesMethod); + + const child = document.createElement('test-child-overrides-method'); + document.body.append(child); + + assert(child.parentClicks === 0, 'parent clicks starts at 0'); + assert(child.childClicks === 0, 'child clicks starts at 0'); + + // Dispatch click event - only child's onClick should fire + child.shadowRoot.dispatchEvent(new CustomEvent('click', { bubbles: true })); + + assert(child.parentClicks === 0, 'parent listener did not fire (overridden by child)'); + assert(child.childClicks === 1, 'child listener fired'); + + // Verify parent instance uses parent's onClick + const parent = document.createElement('test-parent-with-method'); + document.body.append(parent); + + parent.shadowRoot.dispatchEvent(new CustomEvent('click', { bubbles: true })); + + assert(parent.parentClicks === 1, 'parent listener works on parent instance'); + assert(parent.childClicks === undefined, 'parent instance has no child property'); + + child.remove(); + parent.remove(); +}); + +it('plain class without decorators (missing metadata link) works correctly', () => { + // Test that a class without decorators in the middle of the inheritance chain + // works correctly and doesn't have Symbol.metadata polluted onto it + + class DecoratedBase extends XElement { + @property({ type: String, initial: 'base-value' }) + accessor baseProp; + + @property({ type: Number, initial: 1 }) + accessor generation; + } + + // Plain class with NO decorators - this is the "missing link" + class PlainMiddle extends DecoratedBase { + // No decorators! Just plain class extending decorated base + } + + class DecoratedChild extends PlainMiddle { + @property({ type: String, initial: 'child-value' }) + accessor childProp; + + @property({ type: Number, initial: 3 }) + accessor generation; + } + + customElements.define('test-decorated-base-link', DecoratedBase); + customElements.define('test-plain-middle-link', PlainMiddle); + customElements.define('test-decorated-child-link', DecoratedChild); + + // CRITICAL: Verify PlainMiddle doesn't have Symbol.metadata as OWN property + // (it might inherit from parent via prototype chain, but shouldn't have its own) + assert(!Object.hasOwn(PlainMiddle, Symbol.metadata), 'plain class has no own Symbol.metadata property'); + + // Verify DecoratedBase and DecoratedChild DO have Symbol.metadata (from decorators) + assert(DecoratedBase[Symbol.metadata] !== undefined, 'decorated base has Symbol.metadata'); + assert(DecoratedChild[Symbol.metadata] !== undefined, 'decorated child has Symbol.metadata'); + + // Create instances and verify inheritance still works correctly + const base = document.createElement('test-decorated-base-link'); + document.body.append(base); + + assert(base.baseProp === 'base-value', 'base has baseProp'); + assert(base.generation === 1, 'base has generation 1'); + assert(base.childProp === undefined, 'base has no child property'); + + const middle = document.createElement('test-plain-middle-link'); + document.body.append(middle); + + assert(middle.baseProp === 'base-value', 'middle inherits baseProp from base'); + assert(middle.generation === 1, 'middle inherits generation from base'); + assert(middle.childProp === undefined, 'middle has no child property'); + + const child = document.createElement('test-decorated-child-link'); + document.body.append(child); + + assert(child.baseProp === 'base-value', 'child inherits baseProp through plain middle'); + assert(child.childProp === 'child-value', 'child has childProp'); + assert(child.generation === 3, 'child overrides generation'); + + // Verify that modifications to child don't affect middle or base + child.baseProp = 'modified'; + assert(middle.baseProp === 'base-value', 'middle unchanged after child modification'); + assert(base.baseProp === 'base-value', 'base unchanged after child modification'); + + base.remove(); + middle.remove(); + child.remove(); +}); diff --git a/test-next/test-initial-properties.html b/test-next/test-initial-properties.html new file mode 100644 index 0000000..355358b --- /dev/null +++ b/test-next/test-initial-properties.html @@ -0,0 +1,18 @@ + + + + + + + + +

Test Initial Properties

+ + + diff --git a/test-next/test-initial-properties.js b/test-next/test-initial-properties.js new file mode 100644 index 0000000..206eb85 --- /dev/null +++ b/test-next/test-initial-properties.js @@ -0,0 +1,222 @@ +let _initProto, _oneDecs, _init_one, _initProto2, _oneDecs2, _init_one2, _twoDecs, _init_two, _initProto3, _oneDecs3, _init_one3, _twoDecs2, _init_two2, _initProto4, _compoundDecs, _init_compound; +function _applyDecs(e, t, r, n, o, a) { function i(e, t, r) { return function (n, o) { return r && r(n), e[t].call(n, o); }; } function c(e, t) { for (var r = 0; r < e.length; r++) e[r].call(t); return t; } function s(e, t, r, n) { if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); return e; } function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { function m(e) { if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); } var y, v = t[0], g = t[3], b = !u; if (!b) { r || Array.isArray(v) || (v = [v]); var w = {}, S = [], A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; f ? (p || d ? w = { get: _setFunctionName(function () { return g(this); }, n, "get"), set: function (e) { t[4](this, e); } } : w[A] = g, p || _setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); } for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { var D = v[j], E = r ? v[j - 1] : void 0, I = {}, O = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: n, metadata: a, addInitializer: function (e, t) { if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); s(t, "An initializer", "be", !0), c.push(t); }.bind(null, I) }; try { if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { var k, F; O.static = l, O.private = f, f ? 2 === o ? k = function (e) { return m(e), w.value; } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function (e) { return e[n]; }, (o < 2 || 4 === o) && (F = function (e, t) { e[n] = t; })); var N = O.access = { has: f ? h.bind() : function (e) { return n in e; } }; if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { get: w.get, set: w.set } : w[A], O), d) { if ("object" == typeof P && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); } } finally { I.v = !0; } } return (p || d) && u.push(function (e, t) { for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); return t; }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; } function u(e, t) { return Object.defineProperty(e, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: !0, enumerable: !0, value: t }); } if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol.for("Symbol.metadata")]; var f = Object.create(null == l ? null : l), p = function (e, t, r, n) { var o, a, i = [], s = function (t) { return _checkInRHS(t) === e; }, u = new Map(); function l(e) { e && i.push(c.bind(null, e)); } for (var f = 0; f < t.length; f++) { var p = t[f]; if (Array.isArray(p)) { var d = p[1], h = p[2], m = p.length > 3, y = 16 & d, v = !!(8 & d), g = 0 == (d &= 7), b = h + "/" + v; if (!g && !m) { var w = u.get(b); if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); u.set(b, !(d > 2) || d); } applyDec(v ? e : e.prototype, p, y, m ? "#" + h : _toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); } } return l(o), l(a), i; }(e, t, o, f); return r.length || u(e, f), { e: p, get c() { var t = []; return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; } }; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; } +function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; } +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; +class TestElementBasic extends XElement { + static { + [_init_one, _initProto] = _applyDecs(this, [[_oneDecs, 1, "one"]], [], 0, void 0, XElement).e; + } + #A = (_initProto(this), _init_one(this)); + get [(_oneDecs = property({ + type: String, + initial: 'one' + }), "one")]() { + return this.#A; + } + set one(v) { + this.#A = v; + } + static template(host) { + return html`
${host.one}
`; + } +} +customElements.define('test-element-basic-next', TestElementBasic); +class TestElementAnonymous extends XElement { + static { + [_init_one2, _init_two, _initProto2] = _applyDecs(this, [[_oneDecs2, 1, "one"], [_twoDecs, 1, "two"]], [], 0, void 0, XElement).e; + } + #A = (_initProto2(this), _init_one2(this)); + get [(_oneDecs2 = property({ + type: String, + initial: (() => 'one')() + }), _twoDecs = property({ + type: String, + initial: () => 'two' + }), "one")]() { + return this.#A; + } + set one(v) { + this.#A = v; + } + #B = _init_two(this); + get two() { + return this.#B; + } + set two(v) { + this.#B = v; + } + static template(host) { + return html`
${host.one}, ${host.two}
`; + } +} +customElements.define('test-element-anonymous-next', TestElementAnonymous); +class TestElementStatic extends XElement { + static { + [_init_one3, _init_two2, _initProto3] = _applyDecs(this, [[_oneDecs3, 1, "one"], [_twoDecs2, 1, "two"]], [], 0, void 0, XElement).e; + } + static get [(_oneDecs3 = property({ + type: String, + initial: () => TestElementStatic.getOne() + }), _twoDecs2 = property({ + type: String, + initial: () => TestElementStatic.getTwo() + }), "one")]() { + return 'one'; + } + static getOne() { + return this.one; + } + static get two() { + return 'two'; + } + static getTwo() { + return this.two; + } + #A = (_initProto3(this), _init_one3(this)); + get one() { + return this.#A; + } + set one(v) { + this.#A = v; + } + #B = _init_two2(this); + get two() { + return this.#B; + } + set two(v) { + this.#B = v; + } + static template(host) { + return html`
${host.one}, ${host.two}
`; + } +} +customElements.define('test-element-static-next', TestElementStatic); +class Compound { + get foo() { + return 'foo'; + } +} +class TestElementCompound extends XElement { + static { + [_init_compound, _initProto4] = _applyDecs(this, [[_compoundDecs, 1, "compound"]], [], 0, void 0, XElement).e; + } + #A = (_initProto4(this), _init_compound(this)); + get [(_compoundDecs = property({ + type: Compound, + initial: () => new Compound() + }), "compound")]() { + return this.#A; + } + set compound(v) { + this.#A = v; + } + static template(host) { + return html`
${host.compound.foo}
`; + } +} +customElements.define('test-element-compound-next', TestElementCompound); +it('basic initial properties', () => { + const el = document.createElement('test-element-basic-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'one'); +}); +it('basic initial properties (predefined undefined properties)', () => { + const el = document.createElement('test-element-basic-next'); + el.one = undefined; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one'); +}); +it('basic initial properties (predefined null properties)', () => { + const el = document.createElement('test-element-basic-next'); + el.one = null; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one'); +}); +it('basic initial properties (predefined properties)', () => { + const el = document.createElement('test-element-basic-next'); + el.one = 'ONE'; + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE'); +}); +it('basic initial properties (predefined attributes)', () => { + const el = document.createElement('test-element-basic-next'); + el.setAttribute('one', 'ONE'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE'); +}); +it('anonymous initial properties', () => { + const el = document.createElement('test-element-anonymous-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two'); +}); +it('anonymous initial properties (predefined undefined properties)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.one = undefined; + el.two = undefined; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two'); +}); +it('anonymous initial properties (predefined null properties)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.one = null; + el.two = null; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two'); +}); +it('anonymous initial properties (predefined properties)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.one = 'ONE'; + el.two = 'TWO'; + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE, TWO'); +}); +it('anonymous initial properties (predefined attributes)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.setAttribute('one', 'ONE'); + el.setAttribute('two', 'TWO'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE, TWO'); +}); +it('compound initial properties are not shared accross element instances', () => { + const el1 = document.createElement('test-element-compound-next'); + const el2 = document.createElement('test-element-compound-next'); + document.body.append(el1, el2); + assert(el1.shadowRoot.textContent === 'foo'); + assert(el2.shadowRoot.textContent === 'foo'); + assert(el1.compound !== el2.compound); +}); +it('cannot set initial to a bad type', () => { + let _initProto5, _badDecs, _init_bad; + class BadTestElement extends XElement { + static { + [_init_bad, _initProto5] = _applyDecs(this, [[_badDecs, 1, "bad"]], [], 0, void 0, XElement).e; + } + #A = (_initProto5(this), _init_bad(this)); + get [(_badDecs = property({ + type: String, + initial: 0 + }), "bad")]() { + return this.#A; + } + set bad(v) { + this.#A = v; + } + } + customElements.define('bad-test-element-next-1', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Unexpected value for "BadTestElement.prototype.bad" (expected String, got Number).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["assert","it","XElement","property","html","TestElementBasic","_init_one","_initProto","_applyDecs","_oneDecs","e","A","type","String","initial","one","v","template","host","customElements","define","TestElementAnonymous","_init_one2","_init_two","_initProto2","_oneDecs2","_twoDecs","B","two","TestElementStatic","_init_one3","_init_two2","_initProto3","_oneDecs3","_twoDecs2","getOne","getTwo","Compound","foo","TestElementCompound","_init_compound","_initProto4","_compoundDecs","compound","el","document","createElement","body","append","shadowRoot","textContent","undefined","setAttribute","el1","el2","_initProto5","_badDecs","_init_bad","BadTestElement","bad","passed","message","connectedCallback","error","expected"],"sources":["test-initial-properties.src.js"],"sourcesContent":["import { assert, it } from '@netflix/x-test/x-test.js';\nimport { XElement, property, html } from '../x-element-next.js';\n\nclass TestElementBasic extends XElement {\n  @property({ type: String, initial: 'one' })\n  accessor one;\n\n  static template(host) {\n    return html`<div>${host.one}</div>`;\n  }\n}\ncustomElements.define('test-element-basic-next', TestElementBasic);\n\nclass TestElementAnonymous extends XElement {\n  @property({ type: String, initial: (() => 'one')() })\n  accessor one;\n\n  @property({ type: String, initial: () => 'two' })\n  accessor two;\n\n  static template(host) {\n    return html`<div>${host.one}, ${host.two}</div>`;\n  }\n}\ncustomElements.define('test-element-anonymous-next', TestElementAnonymous);\n\nclass TestElementStatic extends XElement {\n  static get one() {\n    return 'one';\n  }\n  static getOne() {\n    return this.one;\n  }\n  static get two() {\n    return 'two';\n  }\n  static getTwo() {\n    return this.two;\n  }\n\n  @property({ type: String, initial: () => TestElementStatic.getOne() })\n  accessor one;\n\n  @property({ type: String, initial: () => TestElementStatic.getTwo() })\n  accessor two;\n\n  static template(host) {\n    return html`<div>${host.one}, ${host.two}</div>`;\n  }\n}\ncustomElements.define('test-element-static-next', TestElementStatic);\n\nclass Compound {\n  get foo() {\n    return 'foo';\n  }\n}\n\nclass TestElementCompound extends XElement {\n  @property({ type: Compound, initial: () => new Compound() })\n  accessor compound;\n\n  static template(host) {\n    return html`<div>${host.compound.foo}</div>`;\n  }\n}\ncustomElements.define('test-element-compound-next', TestElementCompound);\n\nit('basic initial properties', () => {\n  const el = document.createElement('test-element-basic-next');\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one');\n});\n\nit('basic initial properties (predefined undefined properties)', () => {\n  const el = document.createElement('test-element-basic-next');\n  el.one = undefined;\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one');\n});\n\nit('basic initial properties (predefined null properties)', () => {\n  const el = document.createElement('test-element-basic-next');\n  el.one = null;\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one');\n});\n\nit('basic initial properties (predefined properties)', () => {\n  const el = document.createElement('test-element-basic-next');\n  el.one = 'ONE';\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'ONE');\n});\n\nit('basic initial properties (predefined attributes)', () => {\n  const el = document.createElement('test-element-basic-next');\n  el.setAttribute('one', 'ONE');\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'ONE');\n});\n\nit('anonymous initial properties', () => {\n  const el = document.createElement('test-element-anonymous-next');\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one, two');\n});\n\nit('anonymous initial properties (predefined undefined properties)', () => {\n  const el = document.createElement('test-element-anonymous-next');\n  el.one = undefined;\n  el.two = undefined;\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one, two');\n});\n\nit('anonymous initial properties (predefined null properties)', () => {\n  const el = document.createElement('test-element-anonymous-next');\n  el.one = null;\n  el.two = null;\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'one, two');\n});\n\nit('anonymous initial properties (predefined properties)', () => {\n  const el = document.createElement('test-element-anonymous-next');\n  el.one = 'ONE';\n  el.two = 'TWO';\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'ONE, TWO');\n});\n\nit('anonymous initial properties (predefined attributes)', () => {\n  const el = document.createElement('test-element-anonymous-next');\n  el.setAttribute('one', 'ONE');\n  el.setAttribute('two', 'TWO');\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'ONE, TWO');\n});\n\nit('compound initial properties are not shared accross element instances', () => {\n  const el1 = document.createElement('test-element-compound-next');\n  const el2 = document.createElement('test-element-compound-next');\n  document.body.append(el1, el2);\n  assert(el1.shadowRoot.textContent === 'foo');\n  assert(el2.shadowRoot.textContent === 'foo');\n  assert(el1.compound !== el2.compound);\n});\n\nit('cannot set initial to a bad type', () => {\n  class BadTestElement extends XElement {\n    @property({ type: String, initial: 0 })\n    accessor bad;\n  }\n  customElements.define('bad-test-element-next-1', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Unexpected value for \"BadTestElement.prototype.bad\" (expected String, got Number).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/test-next/test-initial-properties.src.js b/test-next/test-initial-properties.src.js new file mode 100644 index 0000000..93c83e9 --- /dev/null +++ b/test-next/test-initial-properties.src.js @@ -0,0 +1,167 @@ +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; + +class TestElementBasic extends XElement { + @property({ type: String, initial: 'one' }) + accessor one; + + static template(host) { + return html`
${host.one}
`; + } +} +customElements.define('test-element-basic-next', TestElementBasic); + +class TestElementAnonymous extends XElement { + @property({ type: String, initial: (() => 'one')() }) + accessor one; + + @property({ type: String, initial: () => 'two' }) + accessor two; + + static template(host) { + return html`
${host.one}, ${host.two}
`; + } +} +customElements.define('test-element-anonymous-next', TestElementAnonymous); + +class TestElementStatic extends XElement { + static get one() { + return 'one'; + } + static getOne() { + return this.one; + } + static get two() { + return 'two'; + } + static getTwo() { + return this.two; + } + + @property({ type: String, initial: () => TestElementStatic.getOne() }) + accessor one; + + @property({ type: String, initial: () => TestElementStatic.getTwo() }) + accessor two; + + static template(host) { + return html`
${host.one}, ${host.two}
`; + } +} +customElements.define('test-element-static-next', TestElementStatic); + +class Compound { + get foo() { + return 'foo'; + } +} + +class TestElementCompound extends XElement { + @property({ type: Compound, initial: () => new Compound() }) + accessor compound; + + static template(host) { + return html`
${host.compound.foo}
`; + } +} +customElements.define('test-element-compound-next', TestElementCompound); + +it('basic initial properties', () => { + const el = document.createElement('test-element-basic-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'one'); +}); + +it('basic initial properties (predefined undefined properties)', () => { + const el = document.createElement('test-element-basic-next'); + el.one = undefined; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one'); +}); + +it('basic initial properties (predefined null properties)', () => { + const el = document.createElement('test-element-basic-next'); + el.one = null; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one'); +}); + +it('basic initial properties (predefined properties)', () => { + const el = document.createElement('test-element-basic-next'); + el.one = 'ONE'; + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE'); +}); + +it('basic initial properties (predefined attributes)', () => { + const el = document.createElement('test-element-basic-next'); + el.setAttribute('one', 'ONE'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE'); +}); + +it('anonymous initial properties', () => { + const el = document.createElement('test-element-anonymous-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two'); +}); + +it('anonymous initial properties (predefined undefined properties)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.one = undefined; + el.two = undefined; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two'); +}); + +it('anonymous initial properties (predefined null properties)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.one = null; + el.two = null; + document.body.append(el); + assert(el.shadowRoot.textContent === 'one, two'); +}); + +it('anonymous initial properties (predefined properties)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.one = 'ONE'; + el.two = 'TWO'; + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE, TWO'); +}); + +it('anonymous initial properties (predefined attributes)', () => { + const el = document.createElement('test-element-anonymous-next'); + el.setAttribute('one', 'ONE'); + el.setAttribute('two', 'TWO'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'ONE, TWO'); +}); + +it('compound initial properties are not shared accross element instances', () => { + const el1 = document.createElement('test-element-compound-next'); + const el2 = document.createElement('test-element-compound-next'); + document.body.append(el1, el2); + assert(el1.shadowRoot.textContent === 'foo'); + assert(el2.shadowRoot.textContent === 'foo'); + assert(el1.compound !== el2.compound); +}); + +it('cannot set initial to a bad type', () => { + class BadTestElement extends XElement { + @property({ type: String, initial: 0 }) + accessor bad; + } + customElements.define('bad-test-element-next-1', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Unexpected value for "BadTestElement.prototype.bad" (expected String, got Number).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); diff --git a/test-next/test-initialization-errors.html b/test-next/test-initialization-errors.html new file mode 100644 index 0000000..85fbe65 --- /dev/null +++ b/test-next/test-initialization-errors.html @@ -0,0 +1,18 @@ + + + + + + + + +

Test Initialization Errors

+ + + diff --git a/test-next/test-initialization-errors.js b/test-next/test-initialization-errors.js new file mode 100644 index 0000000..74fab1c --- /dev/null +++ b/test-next/test-initialization-errors.js @@ -0,0 +1,181 @@ +function _applyDecs(e, t, r, n, o, a) { function i(e, t, r) { return function (n, o) { return r && r(n), e[t].call(n, o); }; } function c(e, t) { for (var r = 0; r < e.length; r++) e[r].call(t); return t; } function s(e, t, r, n) { if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); return e; } function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { function m(e) { if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); } var y, v = t[0], g = t[3], b = !u; if (!b) { r || Array.isArray(v) || (v = [v]); var w = {}, S = [], A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; f ? (p || d ? w = { get: _setFunctionName(function () { return g(this); }, n, "get"), set: function (e) { t[4](this, e); } } : w[A] = g, p || _setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); } for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { var D = v[j], E = r ? v[j - 1] : void 0, I = {}, O = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: n, metadata: a, addInitializer: function (e, t) { if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); s(t, "An initializer", "be", !0), c.push(t); }.bind(null, I) }; try { if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { var k, F; O.static = l, O.private = f, f ? 2 === o ? k = function (e) { return m(e), w.value; } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function (e) { return e[n]; }, (o < 2 || 4 === o) && (F = function (e, t) { e[n] = t; })); var N = O.access = { has: f ? h.bind() : function (e) { return n in e; } }; if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { get: w.get, set: w.set } : w[A], O), d) { if ("object" == typeof P && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); } } finally { I.v = !0; } } return (p || d) && u.push(function (e, t) { for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); return t; }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; } function u(e, t) { return Object.defineProperty(e, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: !0, enumerable: !0, value: t }); } if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol.for("Symbol.metadata")]; var f = Object.create(null == l ? null : l), p = function (e, t, r, n) { var o, a, i = [], s = function (t) { return _checkInRHS(t) === e; }, u = new Map(); function l(e) { e && i.push(c.bind(null, e)); } for (var f = 0; f < t.length; f++) { var p = t[f]; if (Array.isArray(p)) { var d = p[1], h = p[2], m = p.length > 3, y = 16 & d, v = !!(8 & d), g = 0 == (d &= 7), b = h + "/" + v; if (!g && !m) { var w = u.get(b); if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); u.set(b, !(d > 2) || d); } applyDec(v ? e : e.prototype, p, y, m ? "#" + h : _toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); } } return l(o), l(a), i; }(e, t, o, f); return r.length || u(e, f), { e: p, get c() { var t = []; return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; } }; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; } +function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; } +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; +it('errors are thrown in connectedCallback for initializing values with bad types', () => { + let _initProto, _stringDecs, _init_string; + // We cannot try-catch append, so we fake the connectedCallback. + class TestElement extends XElement { + static { + [_init_string, _initProto] = _applyDecs(this, [[_stringDecs, 1, "string"]], [], 0, void 0, XElement).e; + } + #A = (_initProto(this), _init_string(this)); + get [(_stringDecs = property({ + type: String + }), "string")]() { + return this.#A; + } + set string(v) { + this.#A = v; + } + } + customElements.define('test-element-init-type', TestElement); + const el = new TestElement(); + el.string = 5; + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.string" (expected String, got Number).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: The readOnly configuration doesn't exist in the decorator API. +// Users should use accessor-only decorators (no setter) or private fields +// to achieve read-only behavior. Skip this test as readOnly is not supported. +it.skip('errors are thrown in connectedCallback for initializing read-only properties', () => { + // We cannot try-catch append, so we fake the connectedCallback. + class TestElement extends XElement { + static get properties() { + return { + readOnlyProperty: { + type: String, + readOnly: true + } + }; + } + } + customElements.define('test-element-1', TestElement); + const el = new TestElement(); + el.readOnlyProperty = 5; + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Property "TestElement.prototype.readOnlyProperty" is read-only.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('errors are thrown in connectedCallback for initializing computed properties', () => { + let _initProto2, _computedDecs, _init_computed; + // We cannot try-catch append, so we fake the connectedCallback. + class TestElement extends XElement { + static { + [_init_computed, _initProto2] = _applyDecs(this, [[_computedDecs, 1, "computed"]], [], 0, void 0, XElement).e; + } + #A = (_initProto2(this), _init_computed(this)); + get [(_computedDecs = property({ + type: String, + input: [], + compute: () => {} + }), "computed")]() { + return this.#A; + } + set computed(v) { + this.#A = v; + } + } + customElements.define('test-element-init-computed', TestElement); + const el = new TestElement(); + el.computed = 5; + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Property "TestElement.prototype.computed" is computed (computed properties are read-only).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// Depending on the browser — the underlying error is surfaced differently. +// We just match our custom suffix to be agnostic. +it('errors are thrown in connectedCallback when template result fails to render', () => { + let _initProto3, _stringsDecs, _init_strings; + // We cannot try-catch append, so we fake the connectedCallback. + class TestElement extends XElement { + static { + [_init_strings, _initProto3] = _applyDecs(this, [[_stringsDecs, 1, "strings"]], [], 0, void 0, XElement).e; + } + #A = (_initProto3(this), _init_strings(this)); + get [(_stringsDecs = property({ + default: () => ['one', 'two', 'three'] + }), "strings")]() { + return this.#A; + } + set strings(v) { + this.#A = v; + } + static template(host) { + // In this case, the array will fail if items are not template results. + return html`
${host.strings}
`; + } + } + customElements.define('test-element-render-fail', TestElement); + const el = new TestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid template for "TestElement" / at path "test-element-render-fail".'; + message = error.message; + passed = error.message.endsWith(expected); + } + assert(passed, message); +}); + +// Depending on the browser — the underlying error is surfaced differently. +// We just match our custom suffix to be agnostic. +it('errors are thrown in connectedCallback when template result fails to render (with ids, classes, and attributes)', () => { + let _initProto4, _stringsDecs2, _init_strings2; + // We cannot try-catch append, so we fake the connectedCallback. + class TestElement extends XElement { + static { + [_init_strings2, _initProto4] = _applyDecs(this, [[_stringsDecs2, 1, "strings"]], [], 0, void 0, XElement).e; + } + #A = (_initProto4(this), _init_strings2(this)); + get [(_stringsDecs2 = property({ + default: () => ['one', 'two', 'three'] + }), "strings")]() { + return this.#A; + } + set strings(v) { + this.#A = v; + } + static template(host) { + // In this case, the array will fail if items are not template results. + return html`
${host.strings}
`; + } + } + customElements.define('test-element-render-fail-details', TestElement); + const el = new TestElement(); + let passed = false; + let message = 'no error was thrown'; + el.id = 'testing'; + el.classList.add('foo'); + el.classList.add('bar'); + el.setAttribute('boolean', ''); + el.setAttribute('variation', 'primary'); + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid template for "TestElement" / at path "test-element-render-fail-details[id="testing"][class="foo bar"][boolean][variation="primary"]".'; + message = error.message; + passed = error.message.endsWith(expected); + } + assert(passed, message); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["assert","it","XElement","property","html","_initProto","_stringDecs","_init_string","TestElement","_applyDecs","e","A","type","String","string","v","customElements","define","el","passed","message","connectedCallback","error","expected","skip","properties","readOnlyProperty","readOnly","_initProto2","_computedDecs","_init_computed","input","compute","computed","_initProto3","_stringsDecs","_init_strings","default","strings","template","host","endsWith","_initProto4","_stringsDecs2","_init_strings2","id","classList","add","setAttribute"],"sources":["test-initialization-errors.src.js"],"sourcesContent":["import { assert, it } from '@netflix/x-test/x-test.js';\nimport { XElement, property, html } from '../x-element-next.js';\n\nit('errors are thrown in connectedCallback for initializing values with bad types', () => {\n  // We cannot try-catch append, so we fake the connectedCallback.\n  class TestElement extends XElement {\n    @property({ type: String })\n    accessor string;\n  }\n  customElements.define('test-element-init-type', TestElement);\n  const el = new TestElement();\n  el.string = 5;\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Unexpected value for \"TestElement.prototype.string\" (expected String, got Number).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: The readOnly configuration doesn't exist in the decorator API.\n//  Users should use accessor-only decorators (no setter) or private fields\n//  to achieve read-only behavior. Skip this test as readOnly is not supported.\nit.skip('errors are thrown in connectedCallback for initializing read-only properties', () => {\n  // We cannot try-catch append, so we fake the connectedCallback.\n  class TestElement extends XElement {\n    static get properties() {\n      return {\n        readOnlyProperty: {\n          type: String,\n          readOnly: true,\n        },\n      };\n    }\n  }\n  customElements.define('test-element-1', TestElement);\n  const el = new TestElement();\n  el.readOnlyProperty = 5;\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Property \"TestElement.prototype.readOnlyProperty\" is read-only.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('errors are thrown in connectedCallback for initializing computed properties', () => {\n  // We cannot try-catch append, so we fake the connectedCallback.\n  class TestElement extends XElement {\n    @property({\n      type: String,\n      input: [],\n      compute: () => {},\n    })\n    accessor computed;\n  }\n  customElements.define('test-element-init-computed', TestElement);\n  const el = new TestElement();\n  el.computed = 5;\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Property \"TestElement.prototype.computed\" is computed (computed properties are read-only).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// Depending on the browser — the underlying error is surfaced differently.\n// We just match our custom suffix to be agnostic.\nit('errors are thrown in connectedCallback when template result fails to render', () => {\n  // We cannot try-catch append, so we fake the connectedCallback.\n  class TestElement extends XElement {\n    @property({ default: () => ['one', 'two', 'three'] })\n    accessor strings;\n\n    static template(host) {\n      // In this case, the array will fail if items are not template results.\n      return html`<div>${host.strings}</div>`;\n    }\n  }\n  customElements.define('test-element-render-fail', TestElement);\n  const el = new TestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Invalid template for \"TestElement\" / <test-element-render-fail> at path \"test-element-render-fail\".';\n    message = error.message;\n    passed = error.message.endsWith(expected);\n  }\n  assert(passed, message);\n});\n\n// Depending on the browser — the underlying error is surfaced differently.\n// We just match our custom suffix to be agnostic.\nit('errors are thrown in connectedCallback when template result fails to render (with ids, classes, and attributes)', () => {\n  // We cannot try-catch append, so we fake the connectedCallback.\n  class TestElement extends XElement {\n    @property({ default: () => ['one', 'two', 'three'] })\n    accessor strings;\n\n    static template(host) {\n      // In this case, the array will fail if items are not template results.\n      return html`<div>${host.strings}</div>`;\n    }\n  }\n  customElements.define('test-element-render-fail-details', TestElement);\n  const el = new TestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  el.id = 'testing';\n  el.classList.add('foo');\n  el.classList.add('bar');\n  el.setAttribute('boolean', '');\n  el.setAttribute('variation', 'primary');\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Invalid template for \"TestElement\" / <test-element-render-fail-details> at path \"test-element-render-fail-details[id=\"testing\"][class=\"foo bar\"][boolean][variation=\"primary\"]\".';\n    message = error.message;\n    passed = error.message.endsWith(expected);\n  }\n  assert(passed, message);\n});\n"],"mappings":";;;;;AAAA,SAASA,MAAM,EAAEC,EAAE,QAAQ,2BAA2B;AACtD,SAASC,QAAQ,EAAEC,QAAQ,EAAEC,IAAI,QAAQ,sBAAsB;AAE/DH,EAAE,CAAC,+EAA+E,EAAE,MAAM;EAAA,IAAAI,UAAA,EAAAC,WAAA,EAAAC,YAAA;EACxF;EACA,MAAMC,WAAW,SAASN,QAAQ,CAAC;IAAA;MAAA,CAAAK,YAAA,EAAAF,UAAA,IAAAI,UAAA,SAAAH,WAAA,gCAATJ,QAAQ,EAAAQ,CAAA;IAAA;IAAA,CAAAC,CAAA,IAAAN,UAAA,QAAAE,YAAA;IAAA,MAAAD,WAAA,GAC/BH,QAAQ,CAAC;MAAES,IAAI,EAAEC;IAAO,CAAC,CAAC;MAAA,aAAAF,CAAA;IAAA;IAAA,IAClBG,MAAMA,CAAAC,CAAA;MAAA,MAAAJ,CAAA,GAAAI,CAAA;IAAA;EACjB;EACAC,cAAc,CAACC,MAAM,CAAC,wBAAwB,EAAET,WAAW,CAAC;EAC5D,MAAMU,EAAE,GAAG,IAAIV,WAAW,CAAC,CAAC;EAC5BU,EAAE,CAACJ,MAAM,GAAG,CAAC;EACb,IAAIK,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFF,EAAE,CAACG,iBAAiB,CAAC,CAAC;EACxB,CAAC,CAAC,OAAOC,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,oFAAoF;IACrGH,OAAO,GAAGE,KAAK,CAACF,OAAO;IACvBD,MAAM,GAAGG,KAAK,CAACF,OAAO,KAAKG,QAAQ;EACrC;EACAvB,MAAM,CAACmB,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;;AAEF;AACA;AACA;AACAnB,EAAE,CAACuB,IAAI,CAAC,8EAA8E,EAAE,MAAM;EAC5F;EACA,MAAMhB,WAAW,SAASN,QAAQ,CAAC;IACjC,WAAWuB,UAAUA,CAAA,EAAG;MACtB,OAAO;QACLC,gBAAgB,EAAE;UAChBd,IAAI,EAAEC,MAAM;UACZc,QAAQ,EAAE;QACZ;MACF,CAAC;IACH;EACF;EACAX,cAAc,CAACC,MAAM,CAAC,gBAAgB,EAAET,WAAW,CAAC;EACpD,MAAMU,EAAE,GAAG,IAAIV,WAAW,CAAC,CAAC;EAC5BU,EAAE,CAACQ,gBAAgB,GAAG,CAAC;EACvB,IAAIP,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFF,EAAE,CAACG,iBAAiB,CAAC,CAAC;EACxB,CAAC,CAAC,OAAOC,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,iEAAiE;IAClFH,OAAO,GAAGE,KAAK,CAACF,OAAO;IACvBD,MAAM,GAAGG,KAAK,CAACF,OAAO,KAAKG,QAAQ;EACrC;EACAvB,MAAM,CAACmB,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;AAEFnB,EAAE,CAAC,6EAA6E,EAAE,MAAM;EAAA,IAAA2B,WAAA,EAAAC,aAAA,EAAAC,cAAA;EACtF;EACA,MAAMtB,WAAW,SAASN,QAAQ,CAAC;IAAA;MAAA,CAAA4B,cAAA,EAAAF,WAAA,IAAAnB,UAAA,SAAAoB,aAAA,kCAAT3B,QAAQ,EAAAQ,CAAA;IAAA;IAAA,CAAAC,CAAA,IAAAiB,WAAA,QAAAE,cAAA;IAAA,MAAAD,aAAA,GAC/B1B,QAAQ,CAAC;MACRS,IAAI,EAAEC,MAAM;MACZkB,KAAK,EAAE,EAAE;MACTC,OAAO,EAAEA,CAAA,KAAM,CAAC;IAClB,CAAC,CAAC;MAAA,aAAArB,CAAA;IAAA;IAAA,IACOsB,QAAQA,CAAAlB,CAAA;MAAA,MAAAJ,CAAA,GAAAI,CAAA;IAAA;EACnB;EACAC,cAAc,CAACC,MAAM,CAAC,4BAA4B,EAAET,WAAW,CAAC;EAChE,MAAMU,EAAE,GAAG,IAAIV,WAAW,CAAC,CAAC;EAC5BU,EAAE,CAACe,QAAQ,GAAG,CAAC;EACf,IAAId,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFF,EAAE,CAACG,iBAAiB,CAAC,CAAC;EACxB,CAAC,CAAC,OAAOC,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,4FAA4F;IAC7GH,OAAO,GAAGE,KAAK,CAACF,OAAO;IACvBD,MAAM,GAAGG,KAAK,CAACF,OAAO,KAAKG,QAAQ;EACrC;EACAvB,MAAM,CAACmB,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;;AAEF;AACA;AACAnB,EAAE,CAAC,6EAA6E,EAAE,MAAM;EAAA,IAAAiC,WAAA,EAAAC,YAAA,EAAAC,aAAA;EACtF;EACA,MAAM5B,WAAW,SAASN,QAAQ,CAAC;IAAA;MAAA,CAAAkC,aAAA,EAAAF,WAAA,IAAAzB,UAAA,SAAA0B,YAAA,iCAATjC,QAAQ,EAAAQ,CAAA;IAAA;IAAA,CAAAC,CAAA,IAAAuB,WAAA,QAAAE,aAAA;IAAA,MAAAD,YAAA,GAC/BhC,QAAQ,CAAC;MAAEkC,OAAO,EAAEA,CAAA,KAAM,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO;IAAE,CAAC,CAAC;MAAA,aAAA1B,CAAA;IAAA;IAAA,IAC5C2B,OAAOA,CAAAvB,CAAA;MAAA,MAAAJ,CAAA,GAAAI,CAAA;IAAA;IAEhB,OAAOwB,QAAQA,CAACC,IAAI,EAAE;MACpB;MACA,OAAOpC,IAAI,QAAQoC,IAAI,CAACF,OAAO,QAAQ;IACzC;EACF;EACAtB,cAAc,CAACC,MAAM,CAAC,0BAA0B,EAAET,WAAW,CAAC;EAC9D,MAAMU,EAAE,GAAG,IAAIV,WAAW,CAAC,CAAC;EAC5B,IAAIW,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFF,EAAE,CAACG,iBAAiB,CAAC,CAAC;EACxB,CAAC,CAAC,OAAOC,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,qGAAqG;IACtHH,OAAO,GAAGE,KAAK,CAACF,OAAO;IACvBD,MAAM,GAAGG,KAAK,CAACF,OAAO,CAACqB,QAAQ,CAAClB,QAAQ,CAAC;EAC3C;EACAvB,MAAM,CAACmB,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;;AAEF;AACA;AACAnB,EAAE,CAAC,iHAAiH,EAAE,MAAM;EAAA,IAAAyC,WAAA,EAAAC,aAAA,EAAAC,cAAA;EAC1H;EACA,MAAMpC,WAAW,SAASN,QAAQ,CAAC;IAAA;MAAA,CAAA0C,cAAA,EAAAF,WAAA,IAAAjC,UAAA,SAAAkC,aAAA,iCAATzC,QAAQ,EAAAQ,CAAA;IAAA;IAAA,CAAAC,CAAA,IAAA+B,WAAA,QAAAE,cAAA;IAAA,MAAAD,aAAA,GAC/BxC,QAAQ,CAAC;MAAEkC,OAAO,EAAEA,CAAA,KAAM,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO;IAAE,CAAC,CAAC;MAAA,aAAA1B,CAAA;IAAA;IAAA,IAC5C2B,OAAOA,CAAAvB,CAAA;MAAA,MAAAJ,CAAA,GAAAI,CAAA;IAAA;IAEhB,OAAOwB,QAAQA,CAACC,IAAI,EAAE;MACpB;MACA,OAAOpC,IAAI,QAAQoC,IAAI,CAACF,OAAO,QAAQ;IACzC;EACF;EACAtB,cAAc,CAACC,MAAM,CAAC,kCAAkC,EAAET,WAAW,CAAC;EACtE,MAAMU,EAAE,GAAG,IAAIV,WAAW,CAAC,CAAC;EAC5B,IAAIW,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnCF,EAAE,CAAC2B,EAAE,GAAG,SAAS;EACjB3B,EAAE,CAAC4B,SAAS,CAACC,GAAG,CAAC,KAAK,CAAC;EACvB7B,EAAE,CAAC4B,SAAS,CAACC,GAAG,CAAC,KAAK,CAAC;EACvB7B,EAAE,CAAC8B,YAAY,CAAC,SAAS,EAAE,EAAE,CAAC;EAC9B9B,EAAE,CAAC8B,YAAY,CAAC,WAAW,EAAE,SAAS,CAAC;EACvC,IAAI;IACF9B,EAAE,CAACG,iBAAiB,CAAC,CAAC;EACxB,CAAC,CAAC,OAAOC,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,kLAAkL;IACnMH,OAAO,GAAGE,KAAK,CAACF,OAAO;IACvBD,MAAM,GAAGG,KAAK,CAACF,OAAO,CAACqB,QAAQ,CAAClB,QAAQ,CAAC;EAC3C;EACAvB,MAAM,CAACmB,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC","ignoreList":[]} \ No newline at end of file diff --git a/test-next/test-initialization-errors.src.js b/test-next/test-initialization-errors.src.js new file mode 100644 index 0000000..ea5febd --- /dev/null +++ b/test-next/test-initialization-errors.src.js @@ -0,0 +1,137 @@ +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; + +it('errors are thrown in connectedCallback for initializing values with bad types', () => { + // We cannot try-catch append, so we fake the connectedCallback. + class TestElement extends XElement { + @property({ type: String }) + accessor string; + } + customElements.define('test-element-init-type', TestElement); + const el = new TestElement(); + el.string = 5; + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Unexpected value for "TestElement.prototype.string" (expected String, got Number).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: The readOnly configuration doesn't exist in the decorator API. +// Users should use accessor-only decorators (no setter) or private fields +// to achieve read-only behavior. Skip this test as readOnly is not supported. +it.skip('errors are thrown in connectedCallback for initializing read-only properties', () => { + // We cannot try-catch append, so we fake the connectedCallback. + class TestElement extends XElement { + static get properties() { + return { + readOnlyProperty: { + type: String, + readOnly: true, + }, + }; + } + } + customElements.define('test-element-1', TestElement); + const el = new TestElement(); + el.readOnlyProperty = 5; + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Property "TestElement.prototype.readOnlyProperty" is read-only.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('errors are thrown in connectedCallback for initializing computed properties', () => { + // We cannot try-catch append, so we fake the connectedCallback. + class TestElement extends XElement { + @property({ + type: String, + input: [], + compute: () => {}, + }) + accessor computed; + } + customElements.define('test-element-init-computed', TestElement); + const el = new TestElement(); + el.computed = 5; + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Property "TestElement.prototype.computed" is computed (computed properties are read-only).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// Depending on the browser — the underlying error is surfaced differently. +// We just match our custom suffix to be agnostic. +it('errors are thrown in connectedCallback when template result fails to render', () => { + // We cannot try-catch append, so we fake the connectedCallback. + class TestElement extends XElement { + @property({ default: () => ['one', 'two', 'three'] }) + accessor strings; + + static template(host) { + // In this case, the array will fail if items are not template results. + return html`
${host.strings}
`; + } + } + customElements.define('test-element-render-fail', TestElement); + const el = new TestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid template for "TestElement" / at path "test-element-render-fail".'; + message = error.message; + passed = error.message.endsWith(expected); + } + assert(passed, message); +}); + +// Depending on the browser — the underlying error is surfaced differently. +// We just match our custom suffix to be agnostic. +it('errors are thrown in connectedCallback when template result fails to render (with ids, classes, and attributes)', () => { + // We cannot try-catch append, so we fake the connectedCallback. + class TestElement extends XElement { + @property({ default: () => ['one', 'two', 'three'] }) + accessor strings; + + static template(host) { + // In this case, the array will fail if items are not template results. + return html`
${host.strings}
`; + } + } + customElements.define('test-element-render-fail-details', TestElement); + const el = new TestElement(); + let passed = false; + let message = 'no error was thrown'; + el.id = 'testing'; + el.classList.add('foo'); + el.classList.add('bar'); + el.setAttribute('boolean', ''); + el.setAttribute('variation', 'primary'); + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Invalid template for "TestElement" / at path "test-element-render-fail-details[id="testing"][class="foo bar"][boolean][variation="primary"]".'; + message = error.message; + passed = error.message.endsWith(expected); + } + assert(passed, message); +}); diff --git a/test-next/test-internal-properties.html b/test-next/test-internal-properties.html new file mode 100644 index 0000000..011a7b3 --- /dev/null +++ b/test-next/test-internal-properties.html @@ -0,0 +1,18 @@ + + + + + + + + +

Test Internal Properties

+ + + diff --git a/test-next/test-internal-properties.js b/test-next/test-internal-properties.js new file mode 100644 index 0000000..ba28856 --- /dev/null +++ b/test-next/test-internal-properties.js @@ -0,0 +1,318 @@ +let _initProto, _internalPropertyDecs, _init_internalProperty, _get_internalProperty, _set_internalProperty, _internalComputedPropertyDecs, _init_internalComputedProperty, _get_internalComputedProperty, _set_internalComputedProperty, _childrenDecs, _init_children, _get_children, _set_children; +function _applyDecs(e, t, r, n, o, a) { function i(e, t, r) { return function (n, o) { return r && r(n), e[t].call(n, o); }; } function c(e, t) { for (var r = 0; r < e.length; r++) e[r].call(t); return t; } function s(e, t, r, n) { if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); return e; } function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { function m(e) { if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); } var y, v = t[0], g = t[3], b = !u; if (!b) { r || Array.isArray(v) || (v = [v]); var w = {}, S = [], A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; f ? (p || d ? w = { get: _setFunctionName(function () { return g(this); }, n, "get"), set: function (e) { t[4](this, e); } } : w[A] = g, p || _setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); } for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { var D = v[j], E = r ? v[j - 1] : void 0, I = {}, O = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: n, metadata: a, addInitializer: function (e, t) { if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); s(t, "An initializer", "be", !0), c.push(t); }.bind(null, I) }; try { if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { var k, F; O.static = l, O.private = f, f ? 2 === o ? k = function (e) { return m(e), w.value; } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function (e) { return e[n]; }, (o < 2 || 4 === o) && (F = function (e, t) { e[n] = t; })); var N = O.access = { has: f ? h.bind() : function (e) { return n in e; } }; if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { get: w.get, set: w.set } : w[A], O), d) { if ("object" == typeof P && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); } } finally { I.v = !0; } } return (p || d) && u.push(function (e, t) { for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); return t; }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; } function u(e, t) { return Object.defineProperty(e, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: !0, enumerable: !0, value: t }); } if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol.for("Symbol.metadata")]; var f = Object.create(null == l ? null : l), p = function (e, t, r, n) { var o, a, i = [], s = function (t) { return _checkInRHS(t) === e; }, u = new Map(); function l(e) { e && i.push(c.bind(null, e)); } for (var f = 0; f < t.length; f++) { var p = t[f]; if (Array.isArray(p)) { var d = p[1], h = p[2], m = p.length > 3, y = 16 & d, v = !!(8 & d), g = 0 == (d &= 7), b = h + "/" + v; if (!g && !m) { var w = u.get(b); if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); u.set(b, !(d > 2) || d); } applyDec(v ? e : e.prototype, p, y, m ? "#" + h : _toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); } } return l(o), l(a), i; }(e, t, o, f); return r.length || u(e, f), { e: p, get c() { var t = []; return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; } }; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; } +function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; } +// TODO: #346: We likely should rename this to test-private-properties and +// rewrite to target idiomatic private fields in the future. + +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; +class TestElement extends XElement { + static { + [_init_internalProperty, _get_internalProperty, _set_internalProperty, _init_internalComputedProperty, _get_internalComputedProperty, _set_internalComputedProperty, _init_children, _get_children, _set_children, _initProto] = _applyDecs(this, [[_internalPropertyDecs, 1, "internalProperty", o => o.#A, (o, v) => o.#A = v], [_internalComputedPropertyDecs, 1, "internalComputedProperty", o => o.#B, (o, v) => o.#B = v], [_childrenDecs, 1, "children", o => o.#C, (o, v) => o.#C = v]], [], 0, _ => #internalProperty in _, XElement).e; + } + #A = (_initProto(this), _init_internalProperty(this)); + set #internalProperty(v) { + _set_internalProperty(this, v); + } + get #internalProperty() { + return _get_internalProperty(this); + } + #B = _init_internalComputedProperty(this); // This exists on the public interface, we want to ensure that there's no + // issue using this same name on the internal interface. + set #internalComputedProperty(v) { + _set_internalComputedProperty(this, v); + } + get #internalComputedProperty() { + return _get_internalComputedProperty(this); + } + #C = _init_children(this); + set #children(v) { + _set_children(this, v); + } + get #children() { + return _get_children(this); + } + static [(_internalPropertyDecs = property({ + type: String, + initial: 'Ferus' + }), _internalComputedPropertyDecs = property({ + type: String, + input: ['#internalProperty'], + compute: internalProperty => internalProperty + }), _childrenDecs = property({ + // Use a type that's in conflict with the public interface. + type: Boolean + }), "template")](host) { + return html`
${host.#internalProperty}
`; + } +} +customElements.define('test-element-next', TestElement); +it('initialization', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'Ferus', 'initialized as expected'); +}); + +// TODO: #346: We can likely delete. It used to test the "in" operator on +// el.internal proxy, but decorator API uses native private fields (#). +it.skip('can use "has" api or "in" operator.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert('internalProperty' in el.internal, 'The "has" trap does not work.'); +}); + +// TODO: #346: We can likely delete. It used to test Reflect.ownKeys on el.internal +// proxy, but decorator API uses native private fields which don't appear in ownKeys. +it.skip('can use "ownKeys" api.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + const ownKeys = Reflect.ownKeys(el.internal); + assert(ownKeys.length === 3 && ownKeys[0] === 'internalProperty' && ownKeys[1] === 'internalComputedProperty' && ownKeys[2] === 'children', 'The "ownKeys" trap does not work.'); +}); +it('cannot be read on host', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.internalProperty === undefined); +}); +it('cannot be written to on host', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.internalProperty === undefined); + el.internalProperty = 'ignored'; + assert(el.internalProperty === 'ignored'); +}); + +// TODO: #346: We can likely delete. It used to test reading via el.internal proxy, +// but decorator API uses native private fields which can only be accessed within the class. +it.skip('can be read from "internal"', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.internal.internalProperty === 'Ferus'); +}); + +// TODO: #346: We can likely delete. It used to test writing via el.internal proxy, +// but decorator API uses native private fields which can only be modified within the class. +it.skip('can be written to from "internal"', async () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.internal.internalProperty = 'Dromedary'; + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'Dromedary', 'written to as expected'); +}); + +// TODO: #346: We can likely delete. It used to test computed property read-only +// enforcement via el.internal proxy, but decorator API uses native private fields. +it.skip('cannot be written to from "internal" if computed', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.internal.internalComputedProperty = `don't do it`; + } catch (error) { + const expected = 'Property "TestElement.properties.internalComputedProperty" is computed (computed properties are read-only).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy constraints in +// template, but decorator API receives the host directly. Private fields can't be accessed +// from static methods anyway (syntax error). +it.skip('cannot set to known properties', () => { + let _initProto2, _internalPropertyDecs2, _init_internalProperty2, _get_internalProperty2, _set_internalProperty2; + class BadTestElement extends XElement { + static { + [_init_internalProperty2, _get_internalProperty2, _set_internalProperty2, _initProto2] = _applyDecs(this, [[_internalPropertyDecs2, 1, "internalProperty", o => o.#A, (o, v) => o.#A = v]], [], 0, _ => #internalProperty in _, XElement).e; + } + #A = (_initProto2(this), _init_internalProperty2(this)); + set #internalProperty(v) { + _set_internalProperty2(this, v); + } + get #internalProperty() { + return _get_internalProperty2(this); + } + static [(_internalPropertyDecs2 = property({ + type: String + }), "template")](host) { + // This would be a syntax error - can't access private field from static method + // host.#internalProperty = 'Dromedary'; + return html`
${host.#internalProperty}
`; + } + } + customElements.define('bad-test-element-next-1', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Cannot set "BadTestElement.properties.internalProperty" via "properties".'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy errors for +// unknown property access, but decorator API uses native private fields. +it.skip('cannot get unknown properties', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.internal.doesNotExist; + } catch (error) { + const expected = 'Property "TestElement.properties.doesNotExist" does not exist.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy errors for +// unknown property writes, but decorator API uses native private fields. +it.skip('cannot get unknown properties', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.internal.doesNotExist = 'nope'; + } catch (error) { + const expected = 'Property "TestElement.properties.doesNotExist" does not exist.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "defineProperty" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.defineProperty(el.internal, 'foo', {}); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// This is a funny one, you can set to undefined, but we strictly don't let you +// "delete" since it has a different meaning and you strictly cannot delete our +// accessors. +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "delete" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.deleteProperty(el.internal, 'internalProperty'); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "getOwnPropertyDescriptor" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.getOwnPropertyDescriptor(el.internal, 'internalProperty'); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "getPrototypeOf" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.getPrototypeOf(el.internal); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "isExtensible" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.isExtensible(el.internal); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "preventExtensions" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.preventExtensions(el.internal); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "setPrototypeOf" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.setPrototypeOf(el.internal, Array); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["assert","it","XElement","property","html","TestElement","_init_internalProperty","_get_internalProperty","_set_internalProperty","_init_internalComputedProperty","_get_internalComputedProperty","_set_internalComputedProperty","_init_children","_get_children","_set_children","_initProto","_applyDecs","_internalPropertyDecs","o","A","v","_internalComputedPropertyDecs","B","_childrenDecs","C","_","internalProperty","e","#internalProperty","internalComputedProperty","#internalComputedProperty","children","#children","type","String","initial","input","compute","Boolean","host","customElements","define","el","document","createElement","body","append","shadowRoot","textContent","skip","internal","ownKeys","Reflect","length","undefined","Promise","resolve","passed","message","error","expected","_initProto2","_internalPropertyDecs2","_init_internalProperty2","_get_internalProperty2","_set_internalProperty2","BadTestElement","connectedCallback","doesNotExist","defineProperty","deleteProperty","getOwnPropertyDescriptor","getPrototypeOf","isExtensible","preventExtensions","setPrototypeOf","Array"],"sources":["test-internal-properties.src.js"],"sourcesContent":["// TODO: #346: We likely should rename this to test-private-properties and\n//  rewrite to target idiomatic private fields in the future.\n\nimport { assert, it } from '@netflix/x-test/x-test.js';\nimport { XElement, property, html } from '../x-element-next.js';\n\nclass TestElement extends XElement {\n  @property({ type: String, initial: 'Ferus' })\n  accessor #internalProperty;\n\n  @property({\n    type: String,\n    input: ['#internalProperty'],\n    compute: internalProperty => internalProperty,\n  })\n  accessor #internalComputedProperty;\n\n  // This exists on the public interface, we want to ensure that there's no\n  //  issue using this same name on the internal interface.\n  @property({\n    // Use a type that's in conflict with the public interface.\n    type: Boolean,\n  })\n  accessor #children;\n\n  static template(host) {\n    return html`<div>${host.#internalProperty}</div>`;\n  }\n}\ncustomElements.define('test-element-next', TestElement);\n\nit('initialization', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  assert(el.shadowRoot.textContent === 'Ferus', 'initialized as expected');\n});\n\n// TODO: #346: We can likely delete. It used to test the \"in\" operator on\n//  el.internal proxy, but decorator API uses native private fields (#).\nit.skip('can use \"has\" api or \"in\" operator.', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  assert('internalProperty' in el.internal, 'The \"has\" trap does not work.');\n});\n\n// TODO: #346: We can likely delete. It used to test Reflect.ownKeys on el.internal\n//  proxy, but decorator API uses native private fields which don't appear in ownKeys.\nit.skip('can use \"ownKeys\" api.', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  const ownKeys = Reflect.ownKeys(el.internal);\n  assert(\n    ownKeys.length === 3 &&\n    ownKeys[0] === 'internalProperty' &&\n    ownKeys[1] === 'internalComputedProperty' &&\n    ownKeys[2] === 'children',\n    'The \"ownKeys\" trap does not work.'\n  );\n});\n\nit('cannot be read on host', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  assert(el.internalProperty === undefined);\n});\n\nit('cannot be written to on host', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  assert(el.internalProperty === undefined);\n  el.internalProperty = 'ignored';\n  assert(el.internalProperty === 'ignored');\n});\n\n// TODO: #346: We can likely delete. It used to test reading via el.internal proxy,\n//  but decorator API uses native private fields which can only be accessed within the class.\nit.skip('can be read from \"internal\"', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  assert(el.internal.internalProperty === 'Ferus');\n});\n\n// TODO: #346: We can likely delete. It used to test writing via el.internal proxy,\n//  but decorator API uses native private fields which can only be modified within the class.\nit.skip('can be written to from \"internal\"', async () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  el.internal.internalProperty = 'Dromedary';\n\n  // We must await a microtask for the update to take place.\n  await Promise.resolve();\n  assert(el.shadowRoot.textContent === 'Dromedary', 'written to as expected');\n});\n\n// TODO: #346: We can likely delete. It used to test computed property read-only\n//  enforcement via el.internal proxy, but decorator API uses native private fields.\nit.skip('cannot be written to from \"internal\" if computed', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.internal.internalComputedProperty = `don't do it`;\n  } catch (error) {\n    const expected = 'Property \"TestElement.properties.internalComputedProperty\" is computed (computed properties are read-only).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test properties proxy constraints in\n//  template, but decorator API receives the host directly. Private fields can't be accessed\n//  from static methods anyway (syntax error).\nit.skip('cannot set to known properties', () => {\n  class BadTestElement extends XElement {\n    @property({ type: String })\n    accessor #internalProperty;\n\n    static template(host) {\n      // This would be a syntax error - can't access private field from static method\n      // host.#internalProperty = 'Dromedary';\n      return html`<div>${host.#internalProperty}</div>`;\n    }\n  }\n  customElements.define('bad-test-element-next-1', BadTestElement);\n  const el = new BadTestElement();\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.connectedCallback();\n  } catch (error) {\n    const expected = 'Cannot set \"BadTestElement.properties.internalProperty\" via \"properties\".';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test el.internal proxy errors for\n//  unknown property access, but decorator API uses native private fields.\nit.skip('cannot get unknown properties', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.internal.doesNotExist;\n  } catch (error) {\n    const expected = 'Property \"TestElement.properties.doesNotExist\" does not exist.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test el.internal proxy errors for\n//  unknown property writes, but decorator API uses native private fields.\nit.skip('cannot get unknown properties', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.internal.doesNotExist = 'nope';\n  } catch (error) {\n    const expected = 'Property \"TestElement.properties.doesNotExist\" does not exist.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but\n//  decorator API uses native private fields without proxy.\nit.skip('cannot \"defineProperty\" on internal.', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    Reflect.defineProperty(el.internal, 'foo', {});\n  } catch (error) {\n    const expected = 'Invalid use of internal proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// This is a funny one, you can set to undefined, but we strictly don't let you\n// \"delete\" since it has a different meaning and you strictly cannot delete our\n// accessors.\n// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but\n//  decorator API uses native private fields without proxy.\nit.skip('cannot \"delete\" on internal.', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    Reflect.deleteProperty(el.internal, 'internalProperty');\n  } catch (error) {\n    const expected = 'Invalid use of internal proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but\n//  decorator API uses native private fields without proxy.\nit.skip('cannot \"getOwnPropertyDescriptor\" on internal.', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    Reflect.getOwnPropertyDescriptor(el.internal, 'internalProperty');\n  } catch (error) {\n    const expected = 'Invalid use of internal proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but\n//  decorator API uses native private fields without proxy.\nit.skip('cannot \"getPrototypeOf\" on internal.', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    Reflect.getPrototypeOf(el.internal);\n  } catch (error) {\n    const expected = 'Invalid use of internal proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but\n//  decorator API uses native private fields without proxy.\nit.skip('cannot \"isExtensible\" on internal.', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    Reflect.isExtensible(el.internal);\n  } catch (error) {\n    const expected = 'Invalid use of internal proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but\n//  decorator API uses native private fields without proxy.\nit.skip('cannot \"preventExtensions\" on internal.', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    Reflect.preventExtensions(el.internal);\n  } catch (error) {\n    const expected = 'Invalid use of internal proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but\n//  decorator API uses native private fields without proxy.\nit.skip('cannot \"setPrototypeOf\" on internal.', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    Reflect.setPrototypeOf(el.internal, Array);\n  } catch (error) {\n    const expected = 'Invalid use of internal proxy.';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n"],"mappings":";;;;;;AAAA;AACA;;AAEA,SAASA,MAAM,EAAEC,EAAE,QAAQ,2BAA2B;AACtD,SAASC,QAAQ,EAAEC,QAAQ,EAAEC,IAAI,QAAQ,sBAAsB;AAE/D,MAAMC,WAAW,SAASH,QAAQ,CAAC;EAAA;IAAA,CAAAI,sBAAA,EAAAC,qBAAA,EAAAC,qBAAA,EAAAC,8BAAA,EAAAC,6BAAA,EAAAC,6BAAA,EAAAC,cAAA,EAAAC,aAAA,EAAAC,aAAA,EAAAC,UAAA,IAAAC,UAAA,SAAAC,qBAAA,yBAAAC,CAAA,IAAAA,CAAA,EAAAC,CAAA,GAAAD,CAAA,EAAAE,CAAA,KAAAF,CAAA,EAAAC,CAAA,GAAAC,CAAA,IAAAC,6BAAA,iCAAAH,CAAA,IAAAA,CAAA,EAAAI,CAAA,GAAAJ,CAAA,EAAAE,CAAA,KAAAF,CAAA,EAAAI,CAAA,GAAAF,CAAA,IAAAG,aAAA,iBAAAL,CAAA,IAAAA,CAAA,EAAAM,CAAA,GAAAN,CAAA,EAAAE,CAAA,KAAAF,CAAA,EAAAM,CAAA,GAAAJ,CAAA,WAAAK,CAAA,IAExB,CAACC,gBAAgB,IAAAD,CAAA,EAFFvB,QAAQ,EAAAyB,CAAA;EAAA;EAAA,CAAAR,CAAA,IAAAJ,UAAA,QAAAT,sBAAA;EAAA,IAEvB,CAACoB,gBAAgBE,CAAAR,CAAA;IAAAZ,qBAAA,OAAAY,CAAA;EAAA;EAAA,IAAjB,CAACM,gBAAgBE,CAAA;IAAA,OAAArB,qBAAA;EAAA;EAAA,CAAAe,CAAA,GAAAb,8BAAA,QAS1B;EACA;EAAA,IAHS,CAACoB,wBAAwBC,CAAAV,CAAA;IAAAT,6BAAA,OAAAS,CAAA;EAAA;EAAA,IAAzB,CAACS,wBAAwBC,CAAA;IAAA,OAAApB,6BAAA;EAAA;EAAA,CAAAc,CAAA,GAAAZ,cAAA;EAAA,IAQzB,CAACmB,QAAQC,CAAAZ,CAAA;IAAAN,aAAA,OAAAM,CAAA;EAAA;EAAA,IAAT,CAACW,QAAQC,CAAA;IAAA,OAAAnB,aAAA;EAAA;EAElB,SAAAI,qBAAA,GAlBCd,QAAQ,CAAC;IAAE8B,IAAI,EAAEC,MAAM;IAAEC,OAAO,EAAE;EAAQ,CAAC,CAAC,EAAAd,6BAAA,GAG5ClB,QAAQ,CAAC;IACR8B,IAAI,EAAEC,MAAM;IACZE,KAAK,EAAE,CAAC,mBAAmB,CAAC;IAC5BC,OAAO,EAAEX,gBAAgB,IAAIA;EAC/B,CAAC,CAAC,EAAAH,aAAA,GAKDpB,QAAQ,CAAC;IACR;IACA8B,IAAI,EAAEK;EACR,CAAC,CAAC,eAGcC,IAAI,EAAE;IACpB,OAAOnC,IAAI,QAAQmC,IAAI,CAAC,CAACb,gBAAgB,QAAQ;EACnD;AACF;AACAc,cAAc,CAACC,MAAM,CAAC,mBAAmB,EAAEpC,WAAW,CAAC;AAEvDJ,EAAE,CAAC,gBAAgB,EAAE,MAAM;EACzB,MAAMyC,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB1C,MAAM,CAAC0C,EAAE,CAACK,UAAU,CAACC,WAAW,KAAK,OAAO,EAAE,yBAAyB,CAAC;AAC1E,CAAC,CAAC;;AAEF;AACA;AACA/C,EAAE,CAACgD,IAAI,CAAC,qCAAqC,EAAE,MAAM;EACnD,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB1C,MAAM,CAAC,kBAAkB,IAAI0C,EAAE,CAACQ,QAAQ,EAAE,+BAA+B,CAAC;AAC5E,CAAC,CAAC;;AAEF;AACA;AACAjD,EAAE,CAACgD,IAAI,CAAC,wBAAwB,EAAE,MAAM;EACtC,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB,MAAMS,OAAO,GAAGC,OAAO,CAACD,OAAO,CAACT,EAAE,CAACQ,QAAQ,CAAC;EAC5ClD,MAAM,CACJmD,OAAO,CAACE,MAAM,KAAK,CAAC,IACpBF,OAAO,CAAC,CAAC,CAAC,KAAK,kBAAkB,IACjCA,OAAO,CAAC,CAAC,CAAC,KAAK,0BAA0B,IACzCA,OAAO,CAAC,CAAC,CAAC,KAAK,UAAU,EACzB,mCACF,CAAC;AACH,CAAC,CAAC;AAEFlD,EAAE,CAAC,wBAAwB,EAAE,MAAM;EACjC,MAAMyC,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB1C,MAAM,CAAC0C,EAAE,CAAChB,gBAAgB,KAAK4B,SAAS,CAAC;AAC3C,CAAC,CAAC;AAEFrD,EAAE,CAAC,8BAA8B,EAAE,MAAM;EACvC,MAAMyC,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB1C,MAAM,CAAC0C,EAAE,CAAChB,gBAAgB,KAAK4B,SAAS,CAAC;EACzCZ,EAAE,CAAChB,gBAAgB,GAAG,SAAS;EAC/B1B,MAAM,CAAC0C,EAAE,CAAChB,gBAAgB,KAAK,SAAS,CAAC;AAC3C,CAAC,CAAC;;AAEF;AACA;AACAzB,EAAE,CAACgD,IAAI,CAAC,6BAA6B,EAAE,MAAM;EAC3C,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB1C,MAAM,CAAC0C,EAAE,CAACQ,QAAQ,CAACxB,gBAAgB,KAAK,OAAO,CAAC;AAClD,CAAC,CAAC;;AAEF;AACA;AACAzB,EAAE,CAACgD,IAAI,CAAC,mCAAmC,EAAE,YAAY;EACvD,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxBA,EAAE,CAACQ,QAAQ,CAACxB,gBAAgB,GAAG,WAAW;;EAE1C;EACA,MAAM6B,OAAO,CAACC,OAAO,CAAC,CAAC;EACvBxD,MAAM,CAAC0C,EAAE,CAACK,UAAU,CAACC,WAAW,KAAK,WAAW,EAAE,wBAAwB,CAAC;AAC7E,CAAC,CAAC;;AAEF;AACA;AACA/C,EAAE,CAACgD,IAAI,CAAC,kDAAkD,EAAE,MAAM;EAChE,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB,IAAIe,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFhB,EAAE,CAACQ,QAAQ,CAACrB,wBAAwB,GAAG,aAAa;EACtD,CAAC,CAAC,OAAO8B,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,6GAA6G;IAC9HF,OAAO,GAAGC,KAAK,CAACD,OAAO;IACvBD,MAAM,GAAGE,KAAK,CAACD,OAAO,KAAKE,QAAQ;EACrC;EACA5D,MAAM,CAACyD,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;;AAEF;AACA;AACA;AACAzD,EAAE,CAACgD,IAAI,CAAC,gCAAgC,EAAE,MAAM;EAAA,IAAAY,WAAA,EAAAC,sBAAA,EAAAC,uBAAA,EAAAC,sBAAA,EAAAC,sBAAA;EAC9C,MAAMC,cAAc,SAAShE,QAAQ,CAAC;IAAA;MAAA,CAAA6D,uBAAA,EAAAC,sBAAA,EAAAC,sBAAA,EAAAJ,WAAA,IAAA7C,UAAA,SAAA8C,sBAAA,yBAAA5C,CAAA,IAAAA,CAAA,EAAAC,CAAA,GAAAD,CAAA,EAAAE,CAAA,KAAAF,CAAA,EAAAC,CAAA,GAAAC,CAAA,WAAAK,CAAA,IAE3B,CAACC,gBAAgB,IAAAD,CAAA,EAFCvB,QAAQ,EAAAyB,CAAA;IAAA;IAAA,CAAAR,CAAA,IAAA0C,WAAA,QAAAE,uBAAA;IAAA,IAE1B,CAACrC,gBAAgBE,CAAAR,CAAA;MAAA6C,sBAAA,OAAA7C,CAAA;IAAA;IAAA,IAAjB,CAACM,gBAAgBE,CAAA;MAAA,OAAAoC,sBAAA;IAAA;IAE1B,SAAAF,sBAAA,GAHC3D,QAAQ,CAAC;MAAE8B,IAAI,EAAEC;IAAO,CAAC,CAAC,eAGXK,IAAI,EAAE;MACpB;MACA;MACA,OAAOnC,IAAI,QAAQmC,IAAI,CAAC,CAACb,gBAAgB,QAAQ;IACnD;EACF;EACAc,cAAc,CAACC,MAAM,CAAC,yBAAyB,EAAEyB,cAAc,CAAC;EAChE,MAAMxB,EAAE,GAAG,IAAIwB,cAAc,CAAC,CAAC;EAC/B,IAAIT,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFhB,EAAE,CAACyB,iBAAiB,CAAC,CAAC;EACxB,CAAC,CAAC,OAAOR,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,2EAA2E;IAC5FF,OAAO,GAAGC,KAAK,CAACD,OAAO;IACvBD,MAAM,GAAGE,KAAK,CAACD,OAAO,KAAKE,QAAQ;EACrC;EACA5D,MAAM,CAACyD,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;;AAEF;AACA;AACAzD,EAAE,CAACgD,IAAI,CAAC,+BAA+B,EAAE,MAAM;EAC7C,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB,IAAIe,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFhB,EAAE,CAACQ,QAAQ,CAACkB,YAAY;EAC1B,CAAC,CAAC,OAAOT,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,gEAAgE;IACjFF,OAAO,GAAGC,KAAK,CAACD,OAAO;IACvBD,MAAM,GAAGE,KAAK,CAACD,OAAO,KAAKE,QAAQ;EACrC;EACA5D,MAAM,CAACyD,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;;AAEF;AACA;AACAzD,EAAE,CAACgD,IAAI,CAAC,+BAA+B,EAAE,MAAM;EAC7C,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB,IAAIe,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFhB,EAAE,CAACQ,QAAQ,CAACkB,YAAY,GAAG,MAAM;EACnC,CAAC,CAAC,OAAOT,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,gEAAgE;IACjFF,OAAO,GAAGC,KAAK,CAACD,OAAO;IACvBD,MAAM,GAAGE,KAAK,CAACD,OAAO,KAAKE,QAAQ;EACrC;EACA5D,MAAM,CAACyD,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;;AAEF;AACA;AACAzD,EAAE,CAACgD,IAAI,CAAC,sCAAsC,EAAE,MAAM;EACpD,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB,IAAIe,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFN,OAAO,CAACiB,cAAc,CAAC3B,EAAE,CAACQ,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;EAChD,CAAC,CAAC,OAAOS,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,gCAAgC;IACjDF,OAAO,GAAGC,KAAK,CAACD,OAAO;IACvBD,MAAM,GAAGE,KAAK,CAACD,OAAO,KAAKE,QAAQ;EACrC;EACA5D,MAAM,CAACyD,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;;AAEF;AACA;AACA;AACA;AACA;AACAzD,EAAE,CAACgD,IAAI,CAAC,8BAA8B,EAAE,MAAM;EAC5C,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB,IAAIe,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFN,OAAO,CAACkB,cAAc,CAAC5B,EAAE,CAACQ,QAAQ,EAAE,kBAAkB,CAAC;EACzD,CAAC,CAAC,OAAOS,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,gCAAgC;IACjDF,OAAO,GAAGC,KAAK,CAACD,OAAO;IACvBD,MAAM,GAAGE,KAAK,CAACD,OAAO,KAAKE,QAAQ;EACrC;EACA5D,MAAM,CAACyD,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;;AAEF;AACA;AACAzD,EAAE,CAACgD,IAAI,CAAC,gDAAgD,EAAE,MAAM;EAC9D,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB,IAAIe,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFN,OAAO,CAACmB,wBAAwB,CAAC7B,EAAE,CAACQ,QAAQ,EAAE,kBAAkB,CAAC;EACnE,CAAC,CAAC,OAAOS,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,gCAAgC;IACjDF,OAAO,GAAGC,KAAK,CAACD,OAAO;IACvBD,MAAM,GAAGE,KAAK,CAACD,OAAO,KAAKE,QAAQ;EACrC;EACA5D,MAAM,CAACyD,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;;AAEF;AACA;AACAzD,EAAE,CAACgD,IAAI,CAAC,sCAAsC,EAAE,MAAM;EACpD,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB,IAAIe,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFN,OAAO,CAACoB,cAAc,CAAC9B,EAAE,CAACQ,QAAQ,CAAC;EACrC,CAAC,CAAC,OAAOS,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,gCAAgC;IACjDF,OAAO,GAAGC,KAAK,CAACD,OAAO;IACvBD,MAAM,GAAGE,KAAK,CAACD,OAAO,KAAKE,QAAQ;EACrC;EACA5D,MAAM,CAACyD,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;;AAEF;AACA;AACAzD,EAAE,CAACgD,IAAI,CAAC,oCAAoC,EAAE,MAAM;EAClD,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB,IAAIe,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFN,OAAO,CAACqB,YAAY,CAAC/B,EAAE,CAACQ,QAAQ,CAAC;EACnC,CAAC,CAAC,OAAOS,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,gCAAgC;IACjDF,OAAO,GAAGC,KAAK,CAACD,OAAO;IACvBD,MAAM,GAAGE,KAAK,CAACD,OAAO,KAAKE,QAAQ;EACrC;EACA5D,MAAM,CAACyD,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;;AAEF;AACA;AACAzD,EAAE,CAACgD,IAAI,CAAC,yCAAyC,EAAE,MAAM;EACvD,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB,IAAIe,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFN,OAAO,CAACsB,iBAAiB,CAAChC,EAAE,CAACQ,QAAQ,CAAC;EACxC,CAAC,CAAC,OAAOS,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,gCAAgC;IACjDF,OAAO,GAAGC,KAAK,CAACD,OAAO;IACvBD,MAAM,GAAGE,KAAK,CAACD,OAAO,KAAKE,QAAQ;EACrC;EACA5D,MAAM,CAACyD,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC;;AAEF;AACA;AACAzD,EAAE,CAACgD,IAAI,CAAC,sCAAsC,EAAE,MAAM;EACpD,MAAMP,EAAE,GAAGC,QAAQ,CAACC,aAAa,CAAC,mBAAmB,CAAC;EACtDD,QAAQ,CAACE,IAAI,CAACC,MAAM,CAACJ,EAAE,CAAC;EACxB,IAAIe,MAAM,GAAG,KAAK;EAClB,IAAIC,OAAO,GAAG,qBAAqB;EACnC,IAAI;IACFN,OAAO,CAACuB,cAAc,CAACjC,EAAE,CAACQ,QAAQ,EAAE0B,KAAK,CAAC;EAC5C,CAAC,CAAC,OAAOjB,KAAK,EAAE;IACd,MAAMC,QAAQ,GAAG,gCAAgC;IACjDF,OAAO,GAAGC,KAAK,CAACD,OAAO;IACvBD,MAAM,GAAGE,KAAK,CAACD,OAAO,KAAKE,QAAQ;EACrC;EACA5D,MAAM,CAACyD,MAAM,EAAEC,OAAO,CAAC;AACzB,CAAC,CAAC","ignoreList":[]} \ No newline at end of file diff --git a/test-next/test-internal-properties.src.js b/test-next/test-internal-properties.src.js new file mode 100644 index 0000000..2175d8b --- /dev/null +++ b/test-next/test-internal-properties.src.js @@ -0,0 +1,294 @@ +// TODO: #346: We likely should rename this to test-private-properties and +// rewrite to target idiomatic private fields in the future. + +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; + +class TestElement extends XElement { + @property({ type: String, initial: 'Ferus' }) + accessor #internalProperty; + + @property({ + type: String, + input: ['#internalProperty'], + compute: internalProperty => internalProperty, + }) + accessor #internalComputedProperty; + + // This exists on the public interface, we want to ensure that there's no + // issue using this same name on the internal interface. + @property({ + // Use a type that's in conflict with the public interface. + type: Boolean, + }) + accessor #children; + + static template(host) { + return html`
${host.#internalProperty}
`; + } +} +customElements.define('test-element-next', TestElement); + +it('initialization', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.shadowRoot.textContent === 'Ferus', 'initialized as expected'); +}); + +// TODO: #346: We can likely delete. It used to test the "in" operator on +// el.internal proxy, but decorator API uses native private fields (#). +it.skip('can use "has" api or "in" operator.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert('internalProperty' in el.internal, 'The "has" trap does not work.'); +}); + +// TODO: #346: We can likely delete. It used to test Reflect.ownKeys on el.internal +// proxy, but decorator API uses native private fields which don't appear in ownKeys. +it.skip('can use "ownKeys" api.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + const ownKeys = Reflect.ownKeys(el.internal); + assert( + ownKeys.length === 3 && + ownKeys[0] === 'internalProperty' && + ownKeys[1] === 'internalComputedProperty' && + ownKeys[2] === 'children', + 'The "ownKeys" trap does not work.' + ); +}); + +it('cannot be read on host', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.internalProperty === undefined); +}); + +it('cannot be written to on host', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.internalProperty === undefined); + el.internalProperty = 'ignored'; + assert(el.internalProperty === 'ignored'); +}); + +// TODO: #346: We can likely delete. It used to test reading via el.internal proxy, +// but decorator API uses native private fields which can only be accessed within the class. +it.skip('can be read from "internal"', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.internal.internalProperty === 'Ferus'); +}); + +// TODO: #346: We can likely delete. It used to test writing via el.internal proxy, +// but decorator API uses native private fields which can only be modified within the class. +it.skip('can be written to from "internal"', async () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + el.internal.internalProperty = 'Dromedary'; + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(el.shadowRoot.textContent === 'Dromedary', 'written to as expected'); +}); + +// TODO: #346: We can likely delete. It used to test computed property read-only +// enforcement via el.internal proxy, but decorator API uses native private fields. +it.skip('cannot be written to from "internal" if computed', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.internal.internalComputedProperty = `don't do it`; + } catch (error) { + const expected = 'Property "TestElement.properties.internalComputedProperty" is computed (computed properties are read-only).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test properties proxy constraints in +// template, but decorator API receives the host directly. Private fields can't be accessed +// from static methods anyway (syntax error). +it.skip('cannot set to known properties', () => { + class BadTestElement extends XElement { + @property({ type: String }) + accessor #internalProperty; + + static template(host) { + // This would be a syntax error - can't access private field from static method + // host.#internalProperty = 'Dromedary'; + return html`
${host.#internalProperty}
`; + } + } + customElements.define('bad-test-element-next-1', BadTestElement); + const el = new BadTestElement(); + let passed = false; + let message = 'no error was thrown'; + try { + el.connectedCallback(); + } catch (error) { + const expected = 'Cannot set "BadTestElement.properties.internalProperty" via "properties".'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy errors for +// unknown property access, but decorator API uses native private fields. +it.skip('cannot get unknown properties', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.internal.doesNotExist; + } catch (error) { + const expected = 'Property "TestElement.properties.doesNotExist" does not exist.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy errors for +// unknown property writes, but decorator API uses native private fields. +it.skip('cannot get unknown properties', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.internal.doesNotExist = 'nope'; + } catch (error) { + const expected = 'Property "TestElement.properties.doesNotExist" does not exist.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "defineProperty" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.defineProperty(el.internal, 'foo', {}); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// This is a funny one, you can set to undefined, but we strictly don't let you +// "delete" since it has a different meaning and you strictly cannot delete our +// accessors. +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "delete" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.deleteProperty(el.internal, 'internalProperty'); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "getOwnPropertyDescriptor" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.getOwnPropertyDescriptor(el.internal, 'internalProperty'); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "getPrototypeOf" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.getPrototypeOf(el.internal); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "isExtensible" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.isExtensible(el.internal); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "preventExtensions" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.preventExtensions(el.internal); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// TODO: #346: We can likely delete. It used to test el.internal proxy trap, but +// decorator API uses native private fields without proxy. +it.skip('cannot "setPrototypeOf" on internal.', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + Reflect.setPrototypeOf(el.internal, Array); + } catch (error) { + const expected = 'Invalid use of internal proxy.'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); diff --git a/test-next/test-listeners.html b/test-next/test-listeners.html new file mode 100644 index 0000000..04a9880 --- /dev/null +++ b/test-next/test-listeners.html @@ -0,0 +1,18 @@ + + + + + + + + +

Test Listeners

+ + + diff --git a/test-next/test-listeners.js b/test-next/test-listeners.js new file mode 100644 index 0000000..0ca16bd --- /dev/null +++ b/test-next/test-listeners.js @@ -0,0 +1,542 @@ +let _initProto, _initStatic, _clicksDecs, _init_clicks, _connectionsDecs, _init_connections, _countDecs, _init_count, _customEventCountDecs, _init_customEventCount, _customEventOnceCountDecs, _init_customEventOnceCount, _onClickDecs, _onConnectedDecs, _initProto2, _initStatic2, _count1Decs, _init_count2, _count2Decs, _init_count3, _onTestEvent1Decs, _onTestEvent2Decs, _initProto3, _initStatic3, _onceCountDecs, _init_onceCount, _normalCountDecs, _init_normalCount, _onOnceDecs, _onNormalDecs, _initProto4, _initStatic4, _orderDecs, _init_order, _onCaptureDecs, _onBubbleDecs, _initProto5, _initStatic5, _normalCountDecs2, _init_normalCount2, _passiveCountDecs, _init_passiveCount, _onceCountDecs2, _init_onceCount2, _onNormalDecs2, _onPassiveDecs, _onOnceDecs2; +function _applyDecs(e, t, r, n, o, a) { function i(e, t, r) { return function (n, o) { return r && r(n), e[t].call(n, o); }; } function c(e, t) { for (var r = 0; r < e.length; r++) e[r].call(t); return t; } function s(e, t, r, n) { if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); return e; } function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { function m(e) { if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); } var y, v = t[0], g = t[3], b = !u; if (!b) { r || Array.isArray(v) || (v = [v]); var w = {}, S = [], A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; f ? (p || d ? w = { get: _setFunctionName(function () { return g(this); }, n, "get"), set: function (e) { t[4](this, e); } } : w[A] = g, p || _setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); } for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { var D = v[j], E = r ? v[j - 1] : void 0, I = {}, O = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: n, metadata: a, addInitializer: function (e, t) { if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); s(t, "An initializer", "be", !0), c.push(t); }.bind(null, I) }; try { if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { var k, F; O.static = l, O.private = f, f ? 2 === o ? k = function (e) { return m(e), w.value; } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function (e) { return e[n]; }, (o < 2 || 4 === o) && (F = function (e, t) { e[n] = t; })); var N = O.access = { has: f ? h.bind() : function (e) { return n in e; } }; if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { get: w.get, set: w.set } : w[A], O), d) { if ("object" == typeof P && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); } } finally { I.v = !0; } } return (p || d) && u.push(function (e, t) { for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); return t; }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; } function u(e, t) { return Object.defineProperty(e, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: !0, enumerable: !0, value: t }); } if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol.for("Symbol.metadata")]; var f = Object.create(null == l ? null : l), p = function (e, t, r, n) { var o, a, i = [], s = function (t) { return _checkInRHS(t) === e; }, u = new Map(); function l(e) { e && i.push(c.bind(null, e)); } for (var f = 0; f < t.length; f++) { var p = t[f]; if (Array.isArray(p)) { var d = p[1], h = p[2], m = p.length > 3, y = 16 & d, v = !!(8 & d), g = 0 == (d &= 7), b = h + "/" + v; if (!g && !m) { var w = u.get(b); if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); u.set(b, !(d > 2) || d); } applyDec(v ? e : e.prototype, p, y, m ? "#" + h : _toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); } } return l(o), l(a), i; }(e, t, o, f); return r.length || u(e, f), { e: p, get c() { var t = []; return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; } }; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; } +function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; } +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, listener, html } from '../x-element-next.js'; +class TestElementChild extends HTMLElement { + connectedCallback() { + const eventType = 'connected'; + const eventData = { + bubbles: true, + composed: true + }; + this.dispatchEvent(new CustomEvent(eventType, eventData)); + } +} +customElements.define('test-element-child', TestElementChild); +class TestElement extends XElement { + static { + [_init_clicks, _init_connections, _init_count, _init_customEventCount, _init_customEventOnceCount, _initProto, _initStatic] = _applyDecs(this, [[_onClickDecs, 10, "onClick"], [_onConnectedDecs, 10, "onConnected"], [_clicksDecs, 1, "clicks"], [_connectionsDecs, 1, "connections"], [_countDecs, 1, "count"], [_customEventCountDecs, 1, "customEventCount"], [_customEventOnceCountDecs, 1, "customEventOnceCount"]], [], 0, void 0, XElement).e; + _initStatic(this); + } + #A = (_initProto(this), _init_clicks(this)); + get [(_clicksDecs = property({ + type: Number, + default: 0 + }), _connectionsDecs = property({ + type: Number, + default: 0 + }), _countDecs = property({ + type: Number, + default: 0 + }), _customEventCountDecs = property({ + type: Number, + default: 0 + }), _customEventOnceCountDecs = property({ + type: Number, + default: () => 0 + }), _onClickDecs = listener('click'), _onConnectedDecs = listener('connected'), "clicks")]() { + return this.#A; + } + set clicks(v) { + this.#A = v; + } + #B = _init_connections(this); + get connections() { + return this.#B; + } + set connections(v) { + this.#B = v; + } + #C = _init_count(this); + get count() { + return this.#C; + } + set count(v) { + this.#C = v; + } + #D = _init_customEventCount(this); + get customEventCount() { + return this.#D; + } + set customEventCount(v) { + this.#D = v; + } + #E = _init_customEventOnceCount(this); + get customEventOnceCount() { + return this.#E; + } + set customEventOnceCount(v) { + this.#E = v; + } + static onClick(host, evt) { + host.clicks++; + if (evt.target.id === 'increment') { + host.count++; + } else if (evt.target.id === 'decrement') { + host.count--; + } + } + static onConnected(host) { + host.connections++; + } + static onCustomEventOnce(host) { + if (this === TestElement && host.constructor === TestElement) { + host.customEventOnceCount++; + } + } + static onCustomEvent(host) { + if (this === TestElement && host.constructor === TestElement) { + host.customEventCount++; + } + } + static template(host) { + return html` + + + clicks: ${host.clicks} count ${host.count} +
+ + `; + } + connectedCallback() { + super.connectedCallback(); + this.listen(this.shadowRoot, 'custom-event', this.constructor.onCustomEventOnce, { + once: true + }); + this.listen(this.shadowRoot, 'custom-event', this.constructor.onCustomEvent); + } + disconnectedCallback() { + super.disconnectedCallback(); + this.unlisten(this.shadowRoot, 'custom-event', this.constructor.onCustomEventOnce, { + once: true + }); + this.unlisten(this.shadowRoot, 'custom-event', this.constructor.onCustomEvent); + } +} +customElements.define('test-element-next', TestElement); +it('test lifecycle', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.clicks === 0 && el.count === 0, 'initialized as expected'); + el.click(); + assert(el.clicks === 0 && el.count === 0, 'listens on shadowRoot, not host'); + el.shadowRoot.getElementById('increment').click(); + assert(el.clicks === 1 && el.count === 1, 'listens to events'); + el.shadowRoot.getElementById('decrement').click(); + assert(el.clicks === 2 && el.count === 0, 'works for delegated handling'); + document.body.removeChild(el); + el.shadowRoot.getElementById('increment').click(); + assert(el.clicks === 2 && el.count === 0, 'removes listeners on disconnect'); + document.body.append(el); + el.shadowRoot.getElementById('increment').click(); + assert(el.clicks === 3 && el.count === 1, 'adds back listeners on reconnect'); +}); +it('test connectedCallback lifecycle', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + const eventEmitter = el.shadowRoot.getElementById('custom-event-emitter'); + eventEmitter.dispatchEvent(new CustomEvent('custom-event', { + bubbles: true + })); + assert(el.customEventOnceCount === 1); + assert(el.customEventCount === 1); + eventEmitter.dispatchEvent(new CustomEvent('custom-event', { + bubbles: true + })); + assert(el.customEventOnceCount === 1); + assert(el.customEventCount === 2); + document.body.removeChild(el); + eventEmitter.dispatchEvent(new CustomEvent('custom-event', { + bubbles: true + })); + assert(el.customEventOnceCount === 1); + assert(el.customEventCount === 2); +}); +it('test manual lifecycle', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let count = 0; + const onManualCheck = () => count++; + el.listen(el.shadowRoot, 'manual-check', onManualCheck); + el.shadowRoot.dispatchEvent(new CustomEvent('manual-check')); + el.shadowRoot.dispatchEvent(new CustomEvent('manual-check')); + assert(count === 2, 'listener was added'); + el.unlisten(el.shadowRoot, 'manual-check', onManualCheck); + el.shadowRoot.dispatchEvent(new CustomEvent('manual-check')); + assert(count === 2, 'listener was removed'); +}); +it('test synchronous event handling', () => { + // This is subtle, but it tests that if child elements emit events + // synchronously in their first render, delegated event listening from the + // parent will still work. + let count = 0; + const documentListener = () => count++; + document.addEventListener('connected', documentListener); + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(count === 1); + assert(el.connections === count); +}); +it('throws for bad element on listen', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.listen(); + } catch (error) { + const expected = 'Unexpected element passed to listen (expected EventTarget, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('throws for bad type on listen', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.listen(el); + } catch (error) { + const expected = 'Unexpected type passed to listen (expected String, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('throws for bad callback on listen', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.listen(el.shadowRoot, 'test'); + } catch (error) { + const expected = 'Unexpected callback passed to listen (expected Function, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('throws for bad options on listen', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.listen(el.shadowRoot, 'test', () => {}, true); + } catch (error) { + const expected = 'Unexpected options passed to listen (expected Object, got Boolean).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('throws for bad element on unlisten', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.unlisten(); + } catch (error) { + const expected = 'Unexpected element passed to unlisten (expected EventTarget, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('throws for bad type on unlisten', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.unlisten(el); + } catch (error) { + const expected = 'Unexpected type passed to unlisten (expected String, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('throws for bad callback on unlisten', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.unlisten(el.shadowRoot, 'test'); + } catch (error) { + const expected = 'Unexpected callback passed to unlisten (expected Function, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); +it('throws for bad options on unlisten', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.unlisten(el.shadowRoot, 'test', () => {}, true); + } catch (error) { + const expected = 'Unexpected options passed to unlisten (expected Object, got Boolean).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// Test multiple listeners for same event type +class MultiListenerElement extends XElement { + static { + [_init_count2, _init_count3, _initProto2, _initStatic2] = _applyDecs(this, [[_onTestEvent1Decs, 10, "onTestEvent1"], [_onTestEvent2Decs, 10, "onTestEvent2"], [_count1Decs, 1, "count1"], [_count2Decs, 1, "count2"]], [], 0, void 0, XElement).e; + _initStatic2(this); + } + #A = (_initProto2(this), _init_count2(this)); + get [(_count1Decs = property({ + type: Number, + initial: 0 + }), _count2Decs = property({ + type: Number, + initial: 0 + }), _onTestEvent1Decs = listener('test-event'), _onTestEvent2Decs = listener('test-event'), "count1")]() { + return this.#A; + } + set count1(v) { + this.#A = v; + } + #B = _init_count3(this); + get count2() { + return this.#B; + } + set count2(v) { + this.#B = v; + } + static onTestEvent1(host) { + host.count1++; + } + static onTestEvent2(host) { + host.count2++; + } + static template(host) { + return html`
${host.count1}-${host.count2}
`; + } +} +customElements.define('test-multi-listener', MultiListenerElement); +it('multiple listeners for same event type', () => { + const el = document.createElement('test-multi-listener'); + document.body.append(el); + assert(el.count1 === 0 && el.count2 === 0, 'counters start at 0'); + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { + bubbles: true + })); + assert(el.count1 === 1 && el.count2 === 1, 'both listeners fire'); + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { + bubbles: true + })); + assert(el.count1 === 2 && el.count2 === 2, 'both listeners fire on repeat'); + el.remove(); +}); + +// Test listener with once option +class OnceListenerElement extends XElement { + static { + [_init_onceCount, _init_normalCount, _initProto3, _initStatic3] = _applyDecs(this, [[_onOnceDecs, 10, "onOnce"], [_onNormalDecs, 10, "onNormal"], [_onceCountDecs, 1, "onceCount"], [_normalCountDecs, 1, "normalCount"]], [], 0, void 0, XElement).e; + _initStatic3(this); + } + #A = (_initProto3(this), _init_onceCount(this)); + get [(_onceCountDecs = property({ + type: Number, + initial: 0 + }), _normalCountDecs = property({ + type: Number, + initial: 0 + }), _onOnceDecs = listener('test-event', { + once: true + }), _onNormalDecs = listener('test-event'), "onceCount")]() { + return this.#A; + } + set onceCount(v) { + this.#A = v; + } + #B = _init_normalCount(this); + get normalCount() { + return this.#B; + } + set normalCount(v) { + this.#B = v; + } + static onOnce(host) { + host.onceCount++; + } + static onNormal(host) { + host.normalCount++; + } + static template(host) { + return html`
${host.onceCount}-${host.normalCount}
`; + } +} +customElements.define('test-once-listener', OnceListenerElement); +it('listener with once option fires once only', () => { + const el = document.createElement('test-once-listener'); + document.body.append(el); + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { + bubbles: true + })); + assert(el.onceCount === 1 && el.normalCount === 1, 'both fire on first event'); + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { + bubbles: true + })); + assert(el.onceCount === 1 && el.normalCount === 2, 'once listener stops, normal continues'); + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { + bubbles: true + })); + assert(el.onceCount === 1 && el.normalCount === 3, 'once listener still stopped'); + el.remove(); +}); + +// Test listener with capture option +class CaptureListenerElement extends XElement { + static { + [_init_order, _initProto4, _initStatic4] = _applyDecs(this, [[_onCaptureDecs, 10, "onCapture"], [_onBubbleDecs, 10, "onBubble"], [_orderDecs, 1, "order"]], [], 0, void 0, XElement).e; + _initStatic4(this); + } + #A = (_initProto4(this), _init_order(this)); + get [(_orderDecs = property({ + type: Array, + initial: () => [] + }), _onCaptureDecs = listener('test-event', { + capture: true + }), _onBubbleDecs = listener('test-event'), "order")]() { + return this.#A; + } + set order(v) { + this.#A = v; + } + static onCapture(host) { + host.order = [...host.order, 'capture']; + } + static onBubble(host) { + host.order = [...host.order, 'bubble']; + } + static template() { + return html`
`; + } +} +customElements.define('test-capture-listener', CaptureListenerElement); +it('listener with capture option fires in capture phase', () => { + const el = document.createElement('test-capture-listener'); + document.body.append(el); + const child = el.shadowRoot.getElementById('child'); + child.dispatchEvent(new CustomEvent('test-event', { + bubbles: true + })); + assert(el.order.length === 2, 'both listeners fired'); + assert(el.order[0] === 'capture', 'capture listener fired first'); + assert(el.order[1] === 'bubble', 'bubble listener fired second'); + el.remove(); +}); + +// Test multiple listeners with different options +class MixedOptionsElement extends XElement { + static { + [_init_normalCount2, _init_passiveCount, _init_onceCount2, _initProto5, _initStatic5] = _applyDecs(this, [[_onNormalDecs2, 10, "onNormal"], [_onPassiveDecs, 10, "onPassive"], [_onOnceDecs2, 10, "onOnce"], [_normalCountDecs2, 1, "normalCount"], [_passiveCountDecs, 1, "passiveCount"], [_onceCountDecs2, 1, "onceCount"]], [], 0, void 0, XElement).e; + _initStatic5(this); + } + #A = (_initProto5(this), _init_normalCount2(this)); + get [(_normalCountDecs2 = property({ + type: Number, + initial: 0 + }), _passiveCountDecs = property({ + type: Number, + initial: 0 + }), _onceCountDecs2 = property({ + type: Number, + initial: 0 + }), _onNormalDecs2 = listener('test-event'), _onPassiveDecs = listener('test-event', { + passive: true + }), _onOnceDecs2 = listener('test-event', { + once: true + }), "normalCount")]() { + return this.#A; + } + set normalCount(v) { + this.#A = v; + } + #B = _init_passiveCount(this); + get passiveCount() { + return this.#B; + } + set passiveCount(v) { + this.#B = v; + } + #C = _init_onceCount2(this); + get onceCount() { + return this.#C; + } + set onceCount(v) { + this.#C = v; + } + static onNormal(host) { + host.normalCount++; + } + static onPassive(host) { + host.passiveCount++; + } + static onOnce(host) { + host.onceCount++; + } + static template(host) { + return html`
${host.normalCount}-${host.passiveCount}-${host.onceCount}
`; + } +} +customElements.define('test-mixed-options', MixedOptionsElement); +it('multiple listeners with different options', () => { + const el = document.createElement('test-mixed-options'); + document.body.append(el); + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { + bubbles: true + })); + assert(el.normalCount === 1, 'normal listener fires'); + assert(el.passiveCount === 1, 'passive listener fires'); + assert(el.onceCount === 1, 'once listener fires'); + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { + bubbles: true + })); + assert(el.normalCount === 2, 'normal listener fires again'); + assert(el.passiveCount === 2, 'passive listener fires again'); + assert(el.onceCount === 1, 'once listener does not fire again'); + el.remove(); +}); + +// Test disconnection removes all multiple listeners +it('disconnection removes all multiple listeners', () => { + const el = document.createElement('test-multi-listener'); + document.body.append(el); + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { + bubbles: true + })); + assert(el.count1 === 1 && el.count2 === 1, 'both listeners work when connected'); + el.remove(); + el.count1 = 0; + el.count2 = 0; + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { + bubbles: true + })); + assert(el.count1 === 0 && el.count2 === 0, 'neither listener fires when disconnected'); + document.body.append(el); + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { + bubbles: true + })); + assert(el.count1 === 1 && el.count2 === 1, 'both listeners work again when reconnected'); + el.remove(); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["assert","it","XElement","property","listener","html","TestElementChild","HTMLElement","connectedCallback","eventType","eventData","bubbles","composed","dispatchEvent","CustomEvent","customElements","define","TestElement","_init_clicks","_init_connections","_init_count","_init_customEventCount","_init_customEventOnceCount","_initProto","_initStatic","_applyDecs","_onClickDecs","_onConnectedDecs","_clicksDecs","_connectionsDecs","_countDecs","_customEventCountDecs","_customEventOnceCountDecs","e","A","type","Number","default","clicks","v","B","connections","C","count","D","customEventCount","E","customEventOnceCount","onClick","host","evt","target","id","onConnected","onCustomEventOnce","constructor","onCustomEvent","template","listen","shadowRoot","once","disconnectedCallback","unlisten","el","document","createElement","body","append","click","getElementById","removeChild","eventEmitter","onManualCheck","documentListener","addEventListener","passed","message","error","expected","MultiListenerElement","_init_count2","_init_count3","_initProto2","_initStatic2","_onTestEvent1Decs","_onTestEvent2Decs","_count1Decs","_count2Decs","initial","count1","count2","onTestEvent1","onTestEvent2","remove","OnceListenerElement","_init_onceCount","_init_normalCount","_initProto3","_initStatic3","_onOnceDecs","_onNormalDecs","_onceCountDecs","_normalCountDecs","onceCount","normalCount","onOnce","onNormal","CaptureListenerElement","_init_order","_initProto4","_initStatic4","_onCaptureDecs","_onBubbleDecs","_orderDecs","Array","capture","order","onCapture","onBubble","child","length","MixedOptionsElement","_init_normalCount2","_init_passiveCount","_init_onceCount2","_initProto5","_initStatic5","_onNormalDecs2","_onPassiveDecs","_onOnceDecs2","_normalCountDecs2","_passiveCountDecs","_onceCountDecs2","passive","passiveCount","onPassive"],"sources":["test-listeners.src.js"],"sourcesContent":["import { assert, it } from '@netflix/x-test/x-test.js';\nimport { XElement, property, listener, html } from '../x-element-next.js';\n\nclass TestElementChild extends HTMLElement {\n  connectedCallback() {\n    const eventType = 'connected';\n    const eventData = { bubbles: true, composed: true };\n    this.dispatchEvent(new CustomEvent(eventType, eventData));\n  }\n}\ncustomElements.define('test-element-child', TestElementChild);\n\nclass TestElement extends XElement {\n  @property({\n    type: Number,\n    default: 0,\n  })\n  accessor clicks;\n\n  @property({\n    type: Number,\n    default: 0,\n  })\n  accessor connections;\n\n  @property({\n    type: Number,\n    default: 0,\n  })\n  accessor count;\n\n  @property({\n    type: Number,\n    default: 0,\n  })\n  accessor customEventCount;\n\n  @property({\n    type: Number,\n    default: () => 0,\n  })\n  accessor customEventOnceCount;\n\n  @listener('click')\n  static onClick(host, evt) {\n    host.clicks++;\n    if (evt.target.id === 'increment') {\n      host.count++;\n    } else if (evt.target.id === 'decrement') {\n      host.count--;\n    }\n  }\n\n  @listener('connected')\n  static onConnected(host) {\n    host.connections++;\n  }\n\n  static onCustomEventOnce(host) {\n    if (this === TestElement && host.constructor === TestElement) {\n      host.customEventOnceCount++;\n    }\n  }\n\n  static onCustomEvent(host) {\n    if (this === TestElement && host.constructor === TestElement) {\n      host.customEventCount++;\n    }\n  }\n\n  static template(host) {\n    return html`\n      <button id=\"increment\" type=\"button\">+</button>\n      <button id=\"decrement\" type=\"button\">-</button>\n      <span>clicks: ${host.clicks} count ${host.count}</span>\n      <div id=\"custom-event-emitter\"></div>\n      <test-element-child id=\"connected-event-emitter\"></test-element-child>\n    `;\n  }\n\n  connectedCallback() {\n    super.connectedCallback();\n    this.listen(this.shadowRoot, 'custom-event', this.constructor.onCustomEventOnce, { once: true });\n    this.listen(this.shadowRoot, 'custom-event', this.constructor.onCustomEvent);\n  }\n\n  disconnectedCallback() {\n    super.disconnectedCallback();\n    this.unlisten(this.shadowRoot, 'custom-event', this.constructor.onCustomEventOnce, { once: true });\n    this.unlisten(this.shadowRoot, 'custom-event', this.constructor.onCustomEvent);\n  }\n}\ncustomElements.define('test-element-next', TestElement);\n\nit('test lifecycle', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  assert(el.clicks === 0 && el.count === 0, 'initialized as expected');\n\n  el.click();\n  assert(el.clicks === 0 && el.count === 0, 'listens on shadowRoot, not host');\n\n  el.shadowRoot.getElementById('increment').click();\n  assert(el.clicks === 1 && el.count === 1, 'listens to events');\n\n  el.shadowRoot.getElementById('decrement').click();\n  assert(el.clicks === 2 && el.count === 0, 'works for delegated handling');\n\n  document.body.removeChild(el);\n  el.shadowRoot.getElementById('increment').click();\n  assert(el.clicks === 2 && el.count === 0, 'removes listeners on disconnect');\n\n  document.body.append(el);\n  el.shadowRoot.getElementById('increment').click();\n  assert(el.clicks === 3 && el.count === 1, 'adds back listeners on reconnect');\n});\n\nit('test connectedCallback lifecycle', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  const eventEmitter = el.shadowRoot.getElementById('custom-event-emitter');\n  eventEmitter.dispatchEvent(new CustomEvent('custom-event', { bubbles: true }));\n  assert(el.customEventOnceCount === 1);\n  assert(el.customEventCount === 1);\n  eventEmitter.dispatchEvent(new CustomEvent('custom-event', { bubbles: true }));\n  assert(el.customEventOnceCount === 1);\n  assert(el.customEventCount === 2);\n  document.body.removeChild(el);\n  eventEmitter.dispatchEvent(new CustomEvent('custom-event', { bubbles: true }));\n  assert(el.customEventOnceCount === 1);\n  assert(el.customEventCount === 2);\n});\n\nit('test manual lifecycle', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let count = 0;\n  const onManualCheck = () => count++;\n  el.listen(el.shadowRoot, 'manual-check', onManualCheck);\n  el.shadowRoot.dispatchEvent(new CustomEvent('manual-check'));\n  el.shadowRoot.dispatchEvent(new CustomEvent('manual-check'));\n  assert(count === 2, 'listener was added');\n  el.unlisten(el.shadowRoot, 'manual-check', onManualCheck);\n  el.shadowRoot.dispatchEvent(new CustomEvent('manual-check'));\n  assert(count === 2, 'listener was removed');\n});\n\nit('test synchronous event handling', () => {\n  // This is subtle, but it tests that if child elements emit events\n  //  synchronously in their first render, delegated event listening from the\n  //  parent will still work.\n  let count = 0;\n  const documentListener = () => count++;\n  document.addEventListener('connected', documentListener);\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  assert(count === 1);\n  assert(el.connections === count);\n});\n\nit('throws for bad element on listen', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.listen();\n  } catch (error) {\n    const expected = 'Unexpected element passed to listen (expected EventTarget, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('throws for bad type on listen', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.listen(el);\n  } catch (error) {\n    const expected = 'Unexpected type passed to listen (expected String, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('throws for bad callback on listen', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.listen(el.shadowRoot, 'test');\n  } catch (error) {\n    const expected = 'Unexpected callback passed to listen (expected Function, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('throws for bad options on listen', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.listen(el.shadowRoot, 'test', () => {}, true);\n  } catch (error) {\n    const expected = 'Unexpected options passed to listen (expected Object, got Boolean).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('throws for bad element on unlisten', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.unlisten();\n  } catch (error) {\n    const expected = 'Unexpected element passed to unlisten (expected EventTarget, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('throws for bad type on unlisten', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.unlisten(el);\n  } catch (error) {\n    const expected = 'Unexpected type passed to unlisten (expected String, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('throws for bad callback on unlisten', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.unlisten(el.shadowRoot, 'test');\n  } catch (error) {\n    const expected = 'Unexpected callback passed to unlisten (expected Function, got Undefined).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\nit('throws for bad options on unlisten', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  let passed = false;\n  let message = 'no error was thrown';\n  try {\n    el.unlisten(el.shadowRoot, 'test', () => {}, true);\n  } catch (error) {\n    const expected = 'Unexpected options passed to unlisten (expected Object, got Boolean).';\n    message = error.message;\n    passed = error.message === expected;\n  }\n  assert(passed, message);\n});\n\n// Test multiple listeners for same event type\nclass MultiListenerElement extends XElement {\n  @property({ type: Number, initial: 0 })\n  accessor count1;\n\n  @property({ type: Number, initial: 0 })\n  accessor count2;\n\n  @listener('test-event')\n  static onTestEvent1(host) {\n    host.count1++;\n  }\n\n  @listener('test-event')\n  static onTestEvent2(host) {\n    host.count2++;\n  }\n\n  static template(host) {\n    return html`<div>${host.count1}-${host.count2}</div>`;\n  }\n}\ncustomElements.define('test-multi-listener', MultiListenerElement);\n\nit('multiple listeners for same event type', () => {\n  const el = document.createElement('test-multi-listener');\n  document.body.append(el);\n  assert(el.count1 === 0 && el.count2 === 0, 'counters start at 0');\n\n  el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true }));\n  assert(el.count1 === 1 && el.count2 === 1, 'both listeners fire');\n\n  el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true }));\n  assert(el.count1 === 2 && el.count2 === 2, 'both listeners fire on repeat');\n\n  el.remove();\n});\n\n// Test listener with once option\nclass OnceListenerElement extends XElement {\n  @property({ type: Number, initial: 0 })\n  accessor onceCount;\n\n  @property({ type: Number, initial: 0 })\n  accessor normalCount;\n\n  @listener('test-event', { once: true })\n  static onOnce(host) {\n    host.onceCount++;\n  }\n\n  @listener('test-event')\n  static onNormal(host) {\n    host.normalCount++;\n  }\n\n  static template(host) {\n    return html`<div>${host.onceCount}-${host.normalCount}</div>`;\n  }\n}\ncustomElements.define('test-once-listener', OnceListenerElement);\n\nit('listener with once option fires once only', () => {\n  const el = document.createElement('test-once-listener');\n  document.body.append(el);\n\n  el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true }));\n  assert(el.onceCount === 1 && el.normalCount === 1, 'both fire on first event');\n\n  el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true }));\n  assert(el.onceCount === 1 && el.normalCount === 2, 'once listener stops, normal continues');\n\n  el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true }));\n  assert(el.onceCount === 1 && el.normalCount === 3, 'once listener still stopped');\n\n  el.remove();\n});\n\n// Test listener with capture option\nclass CaptureListenerElement extends XElement {\n  @property({ type: Array, initial: () => [] })\n  accessor order;\n\n  @listener('test-event', { capture: true })\n  static onCapture(host) {\n    host.order = [...host.order, 'capture'];\n  }\n\n  @listener('test-event')\n  static onBubble(host) {\n    host.order = [...host.order, 'bubble'];\n  }\n\n  static template() {\n    return html`<div id=\"child\"></div>`;\n  }\n}\ncustomElements.define('test-capture-listener', CaptureListenerElement);\n\nit('listener with capture option fires in capture phase', () => {\n  const el = document.createElement('test-capture-listener');\n  document.body.append(el);\n\n  const child = el.shadowRoot.getElementById('child');\n  child.dispatchEvent(new CustomEvent('test-event', { bubbles: true }));\n\n  assert(el.order.length === 2, 'both listeners fired');\n  assert(el.order[0] === 'capture', 'capture listener fired first');\n  assert(el.order[1] === 'bubble', 'bubble listener fired second');\n\n  el.remove();\n});\n\n// Test multiple listeners with different options\nclass MixedOptionsElement extends XElement {\n  @property({ type: Number, initial: 0 })\n  accessor normalCount;\n\n  @property({ type: Number, initial: 0 })\n  accessor passiveCount;\n\n  @property({ type: Number, initial: 0 })\n  accessor onceCount;\n\n  @listener('test-event')\n  static onNormal(host) {\n    host.normalCount++;\n  }\n\n  @listener('test-event', { passive: true })\n  static onPassive(host) {\n    host.passiveCount++;\n  }\n\n  @listener('test-event', { once: true })\n  static onOnce(host) {\n    host.onceCount++;\n  }\n\n  static template(host) {\n    return html`<div>${host.normalCount}-${host.passiveCount}-${host.onceCount}</div>`;\n  }\n}\ncustomElements.define('test-mixed-options', MixedOptionsElement);\n\nit('multiple listeners with different options', () => {\n  const el = document.createElement('test-mixed-options');\n  document.body.append(el);\n\n  el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true }));\n  assert(el.normalCount === 1, 'normal listener fires');\n  assert(el.passiveCount === 1, 'passive listener fires');\n  assert(el.onceCount === 1, 'once listener fires');\n\n  el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true }));\n  assert(el.normalCount === 2, 'normal listener fires again');\n  assert(el.passiveCount === 2, 'passive listener fires again');\n  assert(el.onceCount === 1, 'once listener does not fire again');\n\n  el.remove();\n});\n\n// Test disconnection removes all multiple listeners\nit('disconnection removes all multiple listeners', () => {\n  const el = document.createElement('test-multi-listener');\n  document.body.append(el);\n\n  el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true }));\n  assert(el.count1 === 1 && el.count2 === 1, 'both listeners work when connected');\n\n  el.remove();\n  el.count1 = 0;\n  el.count2 = 0;\n\n  el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true }));\n  assert(el.count1 === 0 && el.count2 === 0, 'neither listener fires when disconnected');\n\n  document.body.append(el);\n  el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true }));\n  assert(el.count1 === 1 && el.count2 === 1, 'both listeners work again when reconnected');\n\n  el.remove();\n});\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/test-next/test-listeners.src.js b/test-next/test-listeners.src.js new file mode 100644 index 0000000..0879d8c --- /dev/null +++ b/test-next/test-listeners.src.js @@ -0,0 +1,463 @@ +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, listener, html } from '../x-element-next.js'; + +class TestElementChild extends HTMLElement { + connectedCallback() { + const eventType = 'connected'; + const eventData = { bubbles: true, composed: true }; + this.dispatchEvent(new CustomEvent(eventType, eventData)); + } +} +customElements.define('test-element-child', TestElementChild); + +class TestElement extends XElement { + @property({ + type: Number, + default: 0, + }) + accessor clicks; + + @property({ + type: Number, + default: 0, + }) + accessor connections; + + @property({ + type: Number, + default: 0, + }) + accessor count; + + @property({ + type: Number, + default: 0, + }) + accessor customEventCount; + + @property({ + type: Number, + default: () => 0, + }) + accessor customEventOnceCount; + + @listener('click') + static onClick(host, evt) { + host.clicks++; + if (evt.target.id === 'increment') { + host.count++; + } else if (evt.target.id === 'decrement') { + host.count--; + } + } + + @listener('connected') + static onConnected(host) { + host.connections++; + } + + static onCustomEventOnce(host) { + if (this === TestElement && host.constructor === TestElement) { + host.customEventOnceCount++; + } + } + + static onCustomEvent(host) { + if (this === TestElement && host.constructor === TestElement) { + host.customEventCount++; + } + } + + static template(host) { + return html` + + + clicks: ${host.clicks} count ${host.count} +
+ + `; + } + + connectedCallback() { + super.connectedCallback(); + this.listen(this.shadowRoot, 'custom-event', this.constructor.onCustomEventOnce, { once: true }); + this.listen(this.shadowRoot, 'custom-event', this.constructor.onCustomEvent); + } + + disconnectedCallback() { + super.disconnectedCallback(); + this.unlisten(this.shadowRoot, 'custom-event', this.constructor.onCustomEventOnce, { once: true }); + this.unlisten(this.shadowRoot, 'custom-event', this.constructor.onCustomEvent); + } +} +customElements.define('test-element-next', TestElement); + +it('test lifecycle', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(el.clicks === 0 && el.count === 0, 'initialized as expected'); + + el.click(); + assert(el.clicks === 0 && el.count === 0, 'listens on shadowRoot, not host'); + + el.shadowRoot.getElementById('increment').click(); + assert(el.clicks === 1 && el.count === 1, 'listens to events'); + + el.shadowRoot.getElementById('decrement').click(); + assert(el.clicks === 2 && el.count === 0, 'works for delegated handling'); + + document.body.removeChild(el); + el.shadowRoot.getElementById('increment').click(); + assert(el.clicks === 2 && el.count === 0, 'removes listeners on disconnect'); + + document.body.append(el); + el.shadowRoot.getElementById('increment').click(); + assert(el.clicks === 3 && el.count === 1, 'adds back listeners on reconnect'); +}); + +it('test connectedCallback lifecycle', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + const eventEmitter = el.shadowRoot.getElementById('custom-event-emitter'); + eventEmitter.dispatchEvent(new CustomEvent('custom-event', { bubbles: true })); + assert(el.customEventOnceCount === 1); + assert(el.customEventCount === 1); + eventEmitter.dispatchEvent(new CustomEvent('custom-event', { bubbles: true })); + assert(el.customEventOnceCount === 1); + assert(el.customEventCount === 2); + document.body.removeChild(el); + eventEmitter.dispatchEvent(new CustomEvent('custom-event', { bubbles: true })); + assert(el.customEventOnceCount === 1); + assert(el.customEventCount === 2); +}); + +it('test manual lifecycle', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let count = 0; + const onManualCheck = () => count++; + el.listen(el.shadowRoot, 'manual-check', onManualCheck); + el.shadowRoot.dispatchEvent(new CustomEvent('manual-check')); + el.shadowRoot.dispatchEvent(new CustomEvent('manual-check')); + assert(count === 2, 'listener was added'); + el.unlisten(el.shadowRoot, 'manual-check', onManualCheck); + el.shadowRoot.dispatchEvent(new CustomEvent('manual-check')); + assert(count === 2, 'listener was removed'); +}); + +it('test synchronous event handling', () => { + // This is subtle, but it tests that if child elements emit events + // synchronously in their first render, delegated event listening from the + // parent will still work. + let count = 0; + const documentListener = () => count++; + document.addEventListener('connected', documentListener); + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(count === 1); + assert(el.connections === count); +}); + +it('throws for bad element on listen', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.listen(); + } catch (error) { + const expected = 'Unexpected element passed to listen (expected EventTarget, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('throws for bad type on listen', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.listen(el); + } catch (error) { + const expected = 'Unexpected type passed to listen (expected String, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('throws for bad callback on listen', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.listen(el.shadowRoot, 'test'); + } catch (error) { + const expected = 'Unexpected callback passed to listen (expected Function, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('throws for bad options on listen', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.listen(el.shadowRoot, 'test', () => {}, true); + } catch (error) { + const expected = 'Unexpected options passed to listen (expected Object, got Boolean).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('throws for bad element on unlisten', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.unlisten(); + } catch (error) { + const expected = 'Unexpected element passed to unlisten (expected EventTarget, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('throws for bad type on unlisten', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.unlisten(el); + } catch (error) { + const expected = 'Unexpected type passed to unlisten (expected String, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('throws for bad callback on unlisten', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.unlisten(el.shadowRoot, 'test'); + } catch (error) { + const expected = 'Unexpected callback passed to unlisten (expected Function, got Undefined).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +it('throws for bad options on unlisten', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + let passed = false; + let message = 'no error was thrown'; + try { + el.unlisten(el.shadowRoot, 'test', () => {}, true); + } catch (error) { + const expected = 'Unexpected options passed to unlisten (expected Object, got Boolean).'; + message = error.message; + passed = error.message === expected; + } + assert(passed, message); +}); + +// Test multiple listeners for same event type +class MultiListenerElement extends XElement { + @property({ type: Number, initial: 0 }) + accessor count1; + + @property({ type: Number, initial: 0 }) + accessor count2; + + @listener('test-event') + static onTestEvent1(host) { + host.count1++; + } + + @listener('test-event') + static onTestEvent2(host) { + host.count2++; + } + + static template(host) { + return html`
${host.count1}-${host.count2}
`; + } +} +customElements.define('test-multi-listener', MultiListenerElement); + +it('multiple listeners for same event type', () => { + const el = document.createElement('test-multi-listener'); + document.body.append(el); + assert(el.count1 === 0 && el.count2 === 0, 'counters start at 0'); + + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true })); + assert(el.count1 === 1 && el.count2 === 1, 'both listeners fire'); + + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true })); + assert(el.count1 === 2 && el.count2 === 2, 'both listeners fire on repeat'); + + el.remove(); +}); + +// Test listener with once option +class OnceListenerElement extends XElement { + @property({ type: Number, initial: 0 }) + accessor onceCount; + + @property({ type: Number, initial: 0 }) + accessor normalCount; + + @listener('test-event', { once: true }) + static onOnce(host) { + host.onceCount++; + } + + @listener('test-event') + static onNormal(host) { + host.normalCount++; + } + + static template(host) { + return html`
${host.onceCount}-${host.normalCount}
`; + } +} +customElements.define('test-once-listener', OnceListenerElement); + +it('listener with once option fires once only', () => { + const el = document.createElement('test-once-listener'); + document.body.append(el); + + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true })); + assert(el.onceCount === 1 && el.normalCount === 1, 'both fire on first event'); + + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true })); + assert(el.onceCount === 1 && el.normalCount === 2, 'once listener stops, normal continues'); + + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true })); + assert(el.onceCount === 1 && el.normalCount === 3, 'once listener still stopped'); + + el.remove(); +}); + +// Test listener with capture option +class CaptureListenerElement extends XElement { + @property({ type: Array, initial: () => [] }) + accessor order; + + @listener('test-event', { capture: true }) + static onCapture(host) { + host.order = [...host.order, 'capture']; + } + + @listener('test-event') + static onBubble(host) { + host.order = [...host.order, 'bubble']; + } + + static template() { + return html`
`; + } +} +customElements.define('test-capture-listener', CaptureListenerElement); + +it('listener with capture option fires in capture phase', () => { + const el = document.createElement('test-capture-listener'); + document.body.append(el); + + const child = el.shadowRoot.getElementById('child'); + child.dispatchEvent(new CustomEvent('test-event', { bubbles: true })); + + assert(el.order.length === 2, 'both listeners fired'); + assert(el.order[0] === 'capture', 'capture listener fired first'); + assert(el.order[1] === 'bubble', 'bubble listener fired second'); + + el.remove(); +}); + +// Test multiple listeners with different options +class MixedOptionsElement extends XElement { + @property({ type: Number, initial: 0 }) + accessor normalCount; + + @property({ type: Number, initial: 0 }) + accessor passiveCount; + + @property({ type: Number, initial: 0 }) + accessor onceCount; + + @listener('test-event') + static onNormal(host) { + host.normalCount++; + } + + @listener('test-event', { passive: true }) + static onPassive(host) { + host.passiveCount++; + } + + @listener('test-event', { once: true }) + static onOnce(host) { + host.onceCount++; + } + + static template(host) { + return html`
${host.normalCount}-${host.passiveCount}-${host.onceCount}
`; + } +} +customElements.define('test-mixed-options', MixedOptionsElement); + +it('multiple listeners with different options', () => { + const el = document.createElement('test-mixed-options'); + document.body.append(el); + + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true })); + assert(el.normalCount === 1, 'normal listener fires'); + assert(el.passiveCount === 1, 'passive listener fires'); + assert(el.onceCount === 1, 'once listener fires'); + + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true })); + assert(el.normalCount === 2, 'normal listener fires again'); + assert(el.passiveCount === 2, 'passive listener fires again'); + assert(el.onceCount === 1, 'once listener does not fire again'); + + el.remove(); +}); + +// Test disconnection removes all multiple listeners +it('disconnection removes all multiple listeners', () => { + const el = document.createElement('test-multi-listener'); + document.body.append(el); + + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true })); + assert(el.count1 === 1 && el.count2 === 1, 'both listeners work when connected'); + + el.remove(); + el.count1 = 0; + el.count2 = 0; + + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true })); + assert(el.count1 === 0 && el.count2 === 0, 'neither listener fires when disconnected'); + + document.body.append(el); + el.shadowRoot.dispatchEvent(new CustomEvent('test-event', { bubbles: true })); + assert(el.count1 === 1 && el.count2 === 1, 'both listeners work again when reconnected'); + + el.remove(); +}); diff --git a/test-next/test-observed-properties.html b/test-next/test-observed-properties.html new file mode 100644 index 0000000..65b0f8a --- /dev/null +++ b/test-next/test-observed-properties.html @@ -0,0 +1,18 @@ + + + + + + + + +

Test Observed Properties

+ + + diff --git a/test-next/test-observed-properties.js b/test-next/test-observed-properties.js new file mode 100644 index 0000000..8242faa --- /dev/null +++ b/test-next/test-observed-properties.js @@ -0,0 +1,315 @@ +let _initProto, _aDecs, _init_a, _bDecs, _init_b, _cDecs, _init_c, _changesDecs, _init_changes, _poppedDecs, _init_popped, _asyncDecs, _init_async; +function _applyDecs(e, t, r, n, o, a) { function i(e, t, r) { return function (n, o) { return r && r(n), e[t].call(n, o); }; } function c(e, t) { for (var r = 0; r < e.length; r++) e[r].call(t); return t; } function s(e, t, r, n) { if ("function" != typeof e && (n || void 0 !== e)) throw new TypeError(t + " must " + (r || "be") + " a function" + (n ? "" : " or undefined")); return e; } function applyDec(e, t, r, n, o, a, c, u, l, f, p, d, h) { function m(e) { if (!h(e)) throw new TypeError("Attempted to access private element on non-instance"); } var y, v = t[0], g = t[3], b = !u; if (!b) { r || Array.isArray(v) || (v = [v]); var w = {}, S = [], A = 3 === o ? "get" : 4 === o || d ? "set" : "value"; f ? (p || d ? w = { get: _setFunctionName(function () { return g(this); }, n, "get"), set: function (e) { t[4](this, e); } } : w[A] = g, p || _setFunctionName(w[A], n, 2 === o ? "" : A)) : p || (w = Object.getOwnPropertyDescriptor(e, n)); } for (var P = e, j = v.length - 1; j >= 0; j -= r ? 2 : 1) { var D = v[j], E = r ? v[j - 1] : void 0, I = {}, O = { kind: ["field", "accessor", "method", "getter", "setter", "class"][o], name: n, metadata: a, addInitializer: function (e, t) { if (e.v) throw Error("attempted to call addInitializer after decoration was finished"); s(t, "An initializer", "be", !0), c.push(t); }.bind(null, I) }; try { if (b) (y = s(D.call(E, P, O), "class decorators", "return")) && (P = y);else { var k, F; O.static = l, O.private = f, f ? 2 === o ? k = function (e) { return m(e), w.value; } : (o < 4 && (k = i(w, "get", m)), 3 !== o && (F = i(w, "set", m))) : (k = function (e) { return e[n]; }, (o < 2 || 4 === o) && (F = function (e, t) { e[n] = t; })); var N = O.access = { has: f ? h.bind() : function (e) { return n in e; } }; if (k && (N.get = k), F && (N.set = F), P = D.call(E, d ? { get: w.get, set: w.set } : w[A], O), d) { if ("object" == typeof P && P) (y = s(P.get, "accessor.get")) && (w.get = y), (y = s(P.set, "accessor.set")) && (w.set = y), (y = s(P.init, "accessor.init")) && S.push(y);else if (void 0 !== P) throw new TypeError("accessor decorators must return an object with get, set, or init properties or void 0"); } else s(P, (p ? "field" : "method") + " decorators", "return") && (p ? S.push(P) : w[A] = P); } } finally { I.v = !0; } } return (p || d) && u.push(function (e, t) { for (var r = S.length - 1; r >= 0; r--) t = S[r].call(e, t); return t; }), p || b || (f ? d ? u.push(i(w, "get"), i(w, "set")) : u.push(2 === o ? w[A] : i.call.bind(w[A])) : Object.defineProperty(e, n, w)), P; } function u(e, t) { return Object.defineProperty(e, Symbol.metadata || Symbol.for("Symbol.metadata"), { configurable: !0, enumerable: !0, value: t }); } if (arguments.length >= 6) var l = a[Symbol.metadata || Symbol.for("Symbol.metadata")]; var f = Object.create(null == l ? null : l), p = function (e, t, r, n) { var o, a, i = [], s = function (t) { return _checkInRHS(t) === e; }, u = new Map(); function l(e) { e && i.push(c.bind(null, e)); } for (var f = 0; f < t.length; f++) { var p = t[f]; if (Array.isArray(p)) { var d = p[1], h = p[2], m = p.length > 3, y = 16 & d, v = !!(8 & d), g = 0 == (d &= 7), b = h + "/" + v; if (!g && !m) { var w = u.get(b); if (!0 === w || 3 === w && 4 !== d || 4 === w && 3 !== d) throw Error("Attempted to decorate a public method/accessor that has the same name as a previously decorated public method/accessor. This is not currently supported by the decorators plugin. Property name was: " + h); u.set(b, !(d > 2) || d); } applyDec(v ? e : e.prototype, p, y, m ? "#" + h : _toPropertyKey(h), d, n, v ? a = a || [] : o = o || [], i, v, m, g, 1 === d, v && m ? s : r); } } return l(o), l(a), i; }(e, t, o, f); return r.length || u(e, f), { e: p, get c() { var t = []; return r.length && [u(applyDec(e, [r], n, e.name, 5, f, t), f), c.bind(null, t, e)]; } }; } +function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; } +function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } +function _setFunctionName(e, t, n) { "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : ""); try { Object.defineProperty(e, "name", { configurable: !0, value: n ? n + " " + t : t }); } catch (e) {} return e; } +function _checkInRHS(e) { if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null")); return e; } +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; +class TestElement extends XElement { + static { + [_init_a, _init_b, _init_c, _init_changes, _init_popped, _init_async, _initProto] = _applyDecs(this, [[_aDecs, 1, "a"], [_bDecs, 1, "b"], [_cDecs, 1, "c"], [_changesDecs, 1, "changes"], [_poppedDecs, 1, "popped"], [_asyncDecs, 1, "async"]], [], 0, void 0, XElement).e; + } + static get [(_aDecs = property({ + type: String, + observe: (host, value, oldValue) => TestElement.#observeA(host, value, oldValue) + }), _bDecs = property({ + type: String, + observe: (host, value, oldValue) => TestElement.#observeB(host, value, oldValue) + }), _cDecs = property({ + type: String, + input: ['a', 'b'], + compute: (a, b) => TestElement.#computeC(a, b), + observe: (host, value, oldValue) => TestElement.#observeC(host, value, oldValue) + }), _changesDecs = property({ + type: Array, + observe: () => {} + }), _poppedDecs = property({ + type: Boolean, + reflect: true, + observe: (host, value, oldValue) => TestElement.#observePopped(host, value, oldValue) + }), _asyncDecs = property({ + observe: async () => {} + }), "styles")]() { + const styleSheet = new CSSStyleSheet(); + styleSheet.replaceSync(`\ + :host #container { + transition-property: box-shadow; + transition-duration: 300ms; + transition-timing-function: linear; + box-shadow: 0 0 0 1px black; + padding: 10px; + } + + :host([popped]) #container { + box-shadow: 0 0 10px 0 black; + } + `); + return [styleSheet]; + } + #A = (_initProto(this), _init_a(this)); + get a() { + return this.#A; + } + set a(v) { + this.#A = v; + } + #B = _init_b(this); + get b() { + return this.#B; + } + set b(v) { + this.#B = v; + } + #C = _init_c(this); + get c() { + return this.#C; + } + set c(v) { + this.#C = v; + } + #D = _init_changes(this); + get changes() { + return this.#D; + } + set changes(v) { + this.#D = v; + } + #E = _init_popped(this); + get popped() { + return this.#E; + } + set popped(v) { + this.#E = v; + } + #F = _init_async(this); + get async() { + return this.#F; + } + set async(v) { + this.#F = v; + } + static #computeC(a, b) { + return `${a} ${b}`; + } + static #observeA(host, value, oldValue) { + const changes = Object.assign([], host.changes); + changes.push({ + property: 'a', + value, + oldValue + }); + host.changes = changes; + } + static #observeB(host, value, oldValue) { + const changes = Object.assign([], host.changes); + changes.push({ + property: 'b', + value, + oldValue + }); + host.changes = changes; + } + static #observeC(host, value, oldValue) { + const changes = Object.assign([], host.changes); + changes.push({ + property: 'c', + value, + oldValue + }); + host.changes = changes; + } + static #observePopped(host, value, oldValue) { + const changes = Object.assign([], host.changes); + changes.push({ + property: 'popped', + value, + oldValue + }); + host.changes = changes; + } + static template(host) { + return html` +
+
Changes:
+
    + ${(host.changes || []).map(change => { + return html` +
  • + ${change.property}: "${change.oldValue}" → "${change.value}" +
    • + `; + })} +
+
+ `; + } +} +customElements.define('test-element-next', TestElement); +const isObject = obj => obj instanceof Object && obj !== null; +const deepEqual = (a, b) => { + if (a === b) { + return true; + } + return isObject(a) && isObject(b) && + // Note, we ignore non-enumerable properties (Symbols) here. + Object.keys(a).length === Object.keys(b).length && Object.keys(a).every(key => deepEqual(a[key], b[key])); +}; +it('initialized as expected', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert(deepEqual(el.changes, [{ + property: 'c', + value: 'undefined undefined', + oldValue: undefined + }]), 'initialized as expected'); + document.body.removeChild(el); +}); +it('x-element observed properties', async () => { + const el = document.createElement('test-element-next'); + el.a = '11'; + el.b = '22'; + document.body.append(el); + assert(deepEqual(el.changes, [{ + property: 'a', + value: '11', + oldValue: undefined + }, { + property: 'b', + value: '22', + oldValue: undefined + }, { + property: 'c', + value: '11 22', + oldValue: undefined + }]), 'initialized as expected'); + el.b = 'hey'; + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(deepEqual(el.changes, [{ + property: 'a', + value: '11', + oldValue: undefined + }, { + property: 'b', + value: '22', + oldValue: undefined + }, { + property: 'c', + value: '11 22', + oldValue: undefined + }, { + property: 'c', + value: '11 hey', + oldValue: '11 22' + }, { + property: 'b', + value: 'hey', + oldValue: '22' + }]), 'observe callbacks are called when properties change'); + el.b = 'hey'; + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(deepEqual(el.changes, [{ + property: 'a', + value: '11', + oldValue: undefined + }, { + property: 'b', + value: '22', + oldValue: undefined + }, { + property: 'c', + value: '11 22', + oldValue: undefined + }, { + property: 'c', + value: '11 hey', + oldValue: '11 22' + }, { + property: 'b', + value: 'hey', + oldValue: '22' + }]), 'observe callbacks are not called when set property is the same'); + el.popped = true; + + // We must await a microtask for the update to take place. + await Promise.resolve(); + el.setAttribute('popped', 'still technically true'); + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert(deepEqual(el.changes, [{ + property: 'a', + value: '11', + oldValue: undefined + }, { + property: 'b', + value: '22', + oldValue: undefined + }, { + property: 'c', + value: '11 22', + oldValue: undefined + }, { + property: 'c', + value: '11 hey', + oldValue: '11 22' + }, { + property: 'b', + value: 'hey', + oldValue: '22' + }, { + property: 'popped', + value: true, + oldValue: undefined + }]), 'no re-entrance for observed, reflected properties'); +}); +it('child properties are bound before initialization', () => { + let _initProto2, _fooDecs, _init_foo, _initProto3, _fooDecs2, _init_foo2; + const observations = []; + class TestInner extends XElement { + static { + [_init_foo, _initProto2] = _applyDecs(this, [[_fooDecs, 1, "foo"]], [], 0, void 0, XElement).e; + } + #A = (_initProto2(this), _init_foo(this)); + get [(_fooDecs = property({ + type: Boolean, + observe: (host, value) => observations.push(value), + default: false + }), "foo")]() { + return this.#A; + } + set foo(v) { + this.#A = v; + } + } + customElements.define('test-inner-next', TestInner); + class TestOuter extends XElement { + static { + [_init_foo2, _initProto3] = _applyDecs(this, [[_fooDecs2, 1, "foo"]], [], 0, void 0, XElement).e; + } + #A = (_initProto3(this), _init_foo2(this)); + get [(_fooDecs2 = property({ + type: Boolean, + default: true + }), "foo")]() { + return this.#A; + } + set foo(v) { + this.#A = v; + } + static template(host) { + return html``; + } + } + customElements.define('test-outer-next', TestOuter); + const el = document.createElement('test-outer-next'); + document.body.append(el); + assert(observations[0] === true, observations[0]); + assert(observations.length === 1, observations); + el.remove(); +}); +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["assert","it","XElement","property","html","TestElement","_init_a","_init_b","_init_c","_init_changes","_init_popped","_init_async","_initProto","_applyDecs","_aDecs","_bDecs","_cDecs","_changesDecs","_poppedDecs","_asyncDecs","e","type","String","observe","host","value","oldValue","observeA","observeB","input","compute","a","b","computeC","observeC","Array","Boolean","reflect","observePopped","styleSheet","CSSStyleSheet","replaceSync","A","v","B","C","c","D","changes","E","popped","F","async","#computeC","#observeA","Object","assign","push","#observeB","#observeC","#observePopped","template","map","change","customElements","define","isObject","obj","deepEqual","keys","length","every","key","el","document","createElement","body","append","undefined","removeChild","Promise","resolve","setAttribute","_initProto2","_fooDecs","_init_foo","_initProto3","_fooDecs2","_init_foo2","observations","TestInner","default","foo","TestOuter","remove"],"sources":["test-observed-properties.src.js"],"sourcesContent":["import { assert, it } from '@netflix/x-test/x-test.js';\nimport { XElement, property, html } from '../x-element-next.js';\n\nclass TestElement extends XElement {\n  static get styles() {\n    const styleSheet = new CSSStyleSheet();\n    styleSheet.replaceSync(`\\\n      :host #container {\n        transition-property: box-shadow;\n        transition-duration: 300ms;\n        transition-timing-function: linear;\n        box-shadow: 0 0 0 1px black;\n        padding: 10px;\n      }\n\n      :host([popped]) #container {\n        box-shadow: 0 0 10px 0 black;\n      }\n    `);\n    return [styleSheet];\n  }\n\n  @property({\n    type: String,\n    observe: (host, value, oldValue) => TestElement.#observeA(host, value, oldValue),\n  })\n  accessor a;\n\n  @property({\n    type: String,\n    observe: (host, value, oldValue) => TestElement.#observeB(host, value, oldValue),\n  })\n  accessor b;\n\n  @property({\n    type: String,\n    input: ['a', 'b'],\n    compute: (a, b) => TestElement.#computeC(a, b),\n    observe: (host, value, oldValue) => TestElement.#observeC(host, value, oldValue),\n  })\n  accessor c;\n\n  @property({\n    type: Array,\n    observe: () => {},\n  })\n  accessor changes;\n\n  @property({\n    type: Boolean,\n    reflect: true,\n    observe: (host, value, oldValue) => TestElement.#observePopped(host, value, oldValue),\n  })\n  accessor popped;\n\n  @property({\n    observe: async () => {},\n  })\n  accessor async;\n\n  static #computeC(a, b) {\n    return `${a} ${b}`;\n  }\n\n  static #observeA(host, value, oldValue) {\n    const changes = Object.assign([], host.changes);\n    changes.push({ property: 'a', value, oldValue });\n    host.changes = changes;\n  }\n\n  static #observeB(host, value, oldValue) {\n    const changes = Object.assign([], host.changes);\n    changes.push({ property: 'b', value, oldValue });\n    host.changes = changes;\n  }\n\n  static #observeC(host, value, oldValue) {\n    const changes = Object.assign([], host.changes);\n    changes.push({ property: 'c', value, oldValue });\n    host.changes = changes;\n  }\n\n  static #observePopped(host, value, oldValue) {\n    const changes = Object.assign([], host.changes);\n    changes.push({ property: 'popped', value, oldValue });\n    host.changes = changes;\n  }\n\n  static template(host) {\n    return html`\n      <div id=\"container\">\n        <div>Changes:</div>\n        <ul>\n          ${(host.changes || []).map((change => {\n            return html`\n              <li>\n                <code>${change.property}</code>: \"${change.oldValue}\" &#x2192; \"${change.value}\"\n              </li>\n            `;\n          }))}\n        </ul>\n      </div>\n    `;\n  }\n}\n\ncustomElements.define('test-element-next', TestElement);\n\n\nconst isObject = obj => obj instanceof Object && obj !== null;\nconst deepEqual = (a, b) => {\n  if (a === b) {\n    return true;\n  }\n  return (\n    isObject(a) &&\n    isObject(b) &&\n    // Note, we ignore non-enumerable properties (Symbols) here.\n    Object.keys(a).length === Object.keys(b).length &&\n    Object.keys(a).every(key => deepEqual(a[key], b[key]))\n  );\n};\n\nit('initialized as expected', () => {\n  const el = document.createElement('test-element-next');\n  document.body.append(el);\n  assert(\n    deepEqual(el.changes, [\n      { property: 'c', value: 'undefined undefined', oldValue: undefined },\n    ]),\n    'initialized as expected'\n  );\n  document.body.removeChild(el);\n});\n\nit('x-element observed properties', async () => {\n  const el = document.createElement('test-element-next');\n  el.a = '11';\n  el.b = '22';\n  document.body.append(el);\n\n  assert(\n    deepEqual(el.changes, [\n      { property: 'a', value: '11', oldValue: undefined },\n      { property: 'b', value: '22', oldValue: undefined },\n      { property: 'c', value: '11 22', oldValue: undefined },\n    ]),\n    'initialized as expected'\n  );\n\n  el.b = 'hey';\n\n  // We must await a microtask for the update to take place.\n  await Promise.resolve();\n  assert(\n    deepEqual(el.changes, [\n      { property: 'a', value: '11', oldValue: undefined },\n      { property: 'b', value: '22', oldValue: undefined },\n      { property: 'c', value: '11 22', oldValue: undefined },\n      { property: 'c', value: '11 hey', oldValue: '11 22' },\n      { property: 'b', value: 'hey', oldValue: '22' },\n    ]),\n    'observe callbacks are called when properties change'\n  );\n\n  el.b = 'hey';\n\n  // We must await a microtask for the update to take place.\n  await Promise.resolve();\n  assert(\n    deepEqual(el.changes, [\n      { property: 'a', value: '11', oldValue: undefined },\n      { property: 'b', value: '22', oldValue: undefined },\n      { property: 'c', value: '11 22', oldValue: undefined },\n      { property: 'c', value: '11 hey', oldValue: '11 22' },\n      { property: 'b', value: 'hey', oldValue: '22' },\n    ]),\n    'observe callbacks are not called when set property is the same'\n  );\n\n  el.popped = true;\n\n  // We must await a microtask for the update to take place.\n  await Promise.resolve();\n  el.setAttribute('popped', 'still technically true');\n\n  // We must await a microtask for the update to take place.\n  await Promise.resolve();\n  assert(\n    deepEqual(el.changes, [\n      { property: 'a', value: '11', oldValue: undefined },\n      { property: 'b', value: '22', oldValue: undefined },\n      { property: 'c', value: '11 22', oldValue: undefined },\n      { property: 'c', value: '11 hey', oldValue: '11 22' },\n      { property: 'b', value: 'hey', oldValue: '22' },\n      { property: 'popped', value: true, oldValue: undefined },\n    ]),\n    'no re-entrance for observed, reflected properties'\n  );\n});\n\nit('child properties are bound before initialization', () => {\n  const observations = [];\n  class TestInner extends XElement {\n    @property({\n      type: Boolean,\n      observe: (host, value) => observations.push(value),\n      default: false,\n    })\n    accessor foo;\n  }\n  customElements.define('test-inner-next', TestInner);\n  class TestOuter extends XElement {\n    @property({\n      type: Boolean,\n      default: true,\n    })\n    accessor foo;\n\n    static template(host) {\n      return html`<test-inner-next .foo=\"${host.foo}\"></test-inner-next>`;\n    }\n  }\n  customElements.define('test-outer-next', TestOuter);\n  const el = document.createElement('test-outer-next');\n  document.body.append(el);\n  assert(observations[0] === true, observations[0]);\n  assert(observations.length === 1, observations);\n  el.remove();\n});\n"],"mappings":"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","ignoreList":[]} \ No newline at end of file diff --git a/test-next/test-observed-properties.src.js b/test-next/test-observed-properties.src.js new file mode 100644 index 0000000..3af80a5 --- /dev/null +++ b/test-next/test-observed-properties.src.js @@ -0,0 +1,230 @@ +import { assert, it } from '@netflix/x-test/x-test.js'; +import { XElement, property, html } from '../x-element-next.js'; + +class TestElement extends XElement { + static get styles() { + const styleSheet = new CSSStyleSheet(); + styleSheet.replaceSync(`\ + :host #container { + transition-property: box-shadow; + transition-duration: 300ms; + transition-timing-function: linear; + box-shadow: 0 0 0 1px black; + padding: 10px; + } + + :host([popped]) #container { + box-shadow: 0 0 10px 0 black; + } + `); + return [styleSheet]; + } + + @property({ + type: String, + observe: (host, value, oldValue) => TestElement.#observeA(host, value, oldValue), + }) + accessor a; + + @property({ + type: String, + observe: (host, value, oldValue) => TestElement.#observeB(host, value, oldValue), + }) + accessor b; + + @property({ + type: String, + input: ['a', 'b'], + compute: (a, b) => TestElement.#computeC(a, b), + observe: (host, value, oldValue) => TestElement.#observeC(host, value, oldValue), + }) + accessor c; + + @property({ + type: Array, + observe: () => {}, + }) + accessor changes; + + @property({ + type: Boolean, + reflect: true, + observe: (host, value, oldValue) => TestElement.#observePopped(host, value, oldValue), + }) + accessor popped; + + @property({ + observe: async () => {}, + }) + accessor async; + + static #computeC(a, b) { + return `${a} ${b}`; + } + + static #observeA(host, value, oldValue) { + const changes = Object.assign([], host.changes); + changes.push({ property: 'a', value, oldValue }); + host.changes = changes; + } + + static #observeB(host, value, oldValue) { + const changes = Object.assign([], host.changes); + changes.push({ property: 'b', value, oldValue }); + host.changes = changes; + } + + static #observeC(host, value, oldValue) { + const changes = Object.assign([], host.changes); + changes.push({ property: 'c', value, oldValue }); + host.changes = changes; + } + + static #observePopped(host, value, oldValue) { + const changes = Object.assign([], host.changes); + changes.push({ property: 'popped', value, oldValue }); + host.changes = changes; + } + + static template(host) { + return html` +
+
Changes:
+
    + ${(host.changes || []).map((change => { + return html` +
  • + ${change.property}: "${change.oldValue}" → "${change.value}" +
    • + `; + }))} +
+
+ `; + } +} + +customElements.define('test-element-next', TestElement); + + +const isObject = obj => obj instanceof Object && obj !== null; +const deepEqual = (a, b) => { + if (a === b) { + return true; + } + return ( + isObject(a) && + isObject(b) && + // Note, we ignore non-enumerable properties (Symbols) here. + Object.keys(a).length === Object.keys(b).length && + Object.keys(a).every(key => deepEqual(a[key], b[key])) + ); +}; + +it('initialized as expected', () => { + const el = document.createElement('test-element-next'); + document.body.append(el); + assert( + deepEqual(el.changes, [ + { property: 'c', value: 'undefined undefined', oldValue: undefined }, + ]), + 'initialized as expected' + ); + document.body.removeChild(el); +}); + +it('x-element observed properties', async () => { + const el = document.createElement('test-element-next'); + el.a = '11'; + el.b = '22'; + document.body.append(el); + + assert( + deepEqual(el.changes, [ + { property: 'a', value: '11', oldValue: undefined }, + { property: 'b', value: '22', oldValue: undefined }, + { property: 'c', value: '11 22', oldValue: undefined }, + ]), + 'initialized as expected' + ); + + el.b = 'hey'; + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert( + deepEqual(el.changes, [ + { property: 'a', value: '11', oldValue: undefined }, + { property: 'b', value: '22', oldValue: undefined }, + { property: 'c', value: '11 22', oldValue: undefined }, + { property: 'c', value: '11 hey', oldValue: '11 22' }, + { property: 'b', value: 'hey', oldValue: '22' }, + ]), + 'observe callbacks are called when properties change' + ); + + el.b = 'hey'; + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert( + deepEqual(el.changes, [ + { property: 'a', value: '11', oldValue: undefined }, + { property: 'b', value: '22', oldValue: undefined }, + { property: 'c', value: '11 22', oldValue: undefined }, + { property: 'c', value: '11 hey', oldValue: '11 22' }, + { property: 'b', value: 'hey', oldValue: '22' }, + ]), + 'observe callbacks are not called when set property is the same' + ); + + el.popped = true; + + // We must await a microtask for the update to take place. + await Promise.resolve(); + el.setAttribute('popped', 'still technically true'); + + // We must await a microtask for the update to take place. + await Promise.resolve(); + assert( + deepEqual(el.changes, [ + { property: 'a', value: '11', oldValue: undefined }, + { property: 'b', value: '22', oldValue: undefined }, + { property: 'c', value: '11 22', oldValue: undefined }, + { property: 'c', value: '11 hey', oldValue: '11 22' }, + { property: 'b', value: 'hey', oldValue: '22' }, + { property: 'popped', value: true, oldValue: undefined }, + ]), + 'no re-entrance for observed, reflected properties' + ); +}); + +it('child properties are bound before initialization', () => { + const observations = []; + class TestInner extends XElement { + @property({ + type: Boolean, + observe: (host, value) => observations.push(value), + default: false, + }) + accessor foo; + } + customElements.define('test-inner-next', TestInner); + class TestOuter extends XElement { + @property({ + type: Boolean, + default: true, + }) + accessor foo; + + static template(host) { + return html``; + } + } + customElements.define('test-outer-next', TestOuter); + const el = document.createElement('test-outer-next'); + document.body.append(el); + assert(observations[0] === true, observations[0]); + assert(observations.length === 1, observations); + el.remove(); +}); diff --git a/test-next/test-parser.html b/test-next/test-parser.html new file mode 100644 index 0000000..515fb0d --- /dev/null +++ b/test-next/test-parser.html @@ -0,0 +1,18 @@ + + + + + + + + +

Test Parser

+ + + diff --git a/test-next/test-parser.js b/test-next/test-parser.js new file mode 100644 index 0000000..652535e --- /dev/null +++ b/test-next/test-parser.js @@ -0,0 +1,1686 @@ +import { assert, describe, it } from '@netflix/x-test/x-test.js'; +import { XParser } from '../../x-parser.js'; + +// Special symbol to hang test information off of. +const TEST = Symbol(); + +// Placeholder for values which delimit tagged template functions. These are +// not considered by the parser, so the value here has no significance and will +// not show up in any of the resulting fragments from the initial parse. +const VALUE = '…'; + +// Helper to stringify tokens the way we want to write them in our assertions. +const escape = string => { + return string + .replaceAll('\'', '\\\'') + .replaceAll('\n', '\\n') + .replaceAll('\\u', '\\\\u'); +}; +const stringifyObject = object => { + if (object === null) { + return 'null'; + } + let text = '{ '; + const keys = [...Object.keys(object)]; + let index = 0; + for (const key of keys) { + const value = object[key]; + switch (typeof value) { + case 'object': + text += `${key}: ${stringifyObject(value)}`; + break; + case 'string': + text += `${key}: '${escape(value)}'`; + break; + case 'undefined': + case 'number': + case 'boolean': + text += `${key}: ${value}`; + break; + default: + // Make sure we print _something_ for debugging even if it’s wrong. + text += `${key}: "${value}"`; + } + if (index++ < keys.length - 1) { + text += ', '; + } + } + text += ' }'; + return text; +}; +const stringifyTokens = tokens => { + const lines = []; + for (const token of tokens) { + lines.push(` ${stringifyObject(token)},`); + } + return `[\n${lines.join('\n')}\n]`; +}; + +// Helper for figuring out if the tokens we got were correct. +const isObject = obj => obj instanceof Object && obj !== null; +const deepEqual = (a, b) => { + if (a === b) { + return true; + } + return ( + isObject(a) && + isObject(b) && + // Note, we ignore non-enumerable properties (Symbols) here. + Object.keys(a).length === Object.keys(b).length && + Object.keys(a).every(key => deepEqual(a[key], b[key])) + ); +}; + +// Simple helper for asserting thrown messages. +const assertThrows = (callback, expectedMessage, options) => { + let thrown = false; + try { + callback(); + } catch (error) { + thrown = true; + if (options?.startsWith === true) { + assert(error.message.startsWith(expectedMessage), error.message); + } else { + assert(error.message === expectedMessage, error.message); + } + } + assert(thrown, 'no error was thrown'); +}; + +// Simpler helper to add some test information under a TEST symbol. +const wrapper = strings => { + const tokens = []; + const onToken = (type, index, start, end, substring) => { + tokens.push({ type, index, start, end, substring }); + }; + XParser.parse(strings, onToken); + tokens[TEST] = { strings }; + return tokens; +}; + +// Simple function to return strings array from tagged template function call. +// Since IDEs will pick up on the “html” syntax, they should highlight, which +// will make this more readable. +const html = strings => wrapper(strings); + +// Certain tests require that we write _terribly broken_ html. To prevent IDEs +// from choking when trying to highlight, we also have a “htmlol” function. +const htmlol = strings => wrapper(strings); + +describe('basic', () => { + it('empty template works', () => { + const expectedTokens = []; + const tokens = html``; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('single string works', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 4, substring: 'div' }, + { type: 'start-tag-close', index: 0, start: 4, end: 5, substring: '>' }, + { type: 'text-start', index: 0, start: 5, end: 5, substring: '' }, + { type: 'text-plaintext', index: 0, start: 5, end: 22, substring: 'No interpolation.' }, + { type: 'text-end', index: 0, start: 22, end: 22, substring: '' }, + { type: 'end-tag-open', index: 0, start: 22, end: 24, substring: '' }, + ]; + const tokens = html`
No interpolation.
`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('multi-line string works', () => { + const expectedTokens = [ + { type: 'text-start', index: 0, start: 0, end: 0, substring: '' }, + { type: 'text-plaintext', index: 0, start: 0, end: 37, substring: '\n one\n two\n three\n ' }, + { type: 'text-end', index: 0, start: 37, end: 37, substring: '' }, + ]; + const tokens = html` + one + two + three + `; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); +}); + +describe('comments', () => { + it('comments work', () => { + const expectedTokens = [ + { type: 'comment-open', index: 0, start: 0, end: 4, substring: '' }, + ]; + const tokens = html``; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('multi-line comments work', () => { + const expectedTokens = [ + { type: 'comment-open', index: 0, start: 0, end: 4, substring: '' }, + ]; + const tokens = html``; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); +}); + +describe('character references', () => { + it('accepts references in replaceable character data', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 4, substring: 'div' }, + { type: 'start-tag-close', index: 0, start: 4, end: 5, substring: '>' }, + { type: 'text-start', index: 0, start: 5, end: 5, substring: '' }, + { type: 'text-reference', index: 0, start: 5, end: 11, substring: '{' }, + { type: 'text-plaintext', index: 0, start: 11, end: 13, substring: '--' }, + { type: 'text-reference', index: 0, start: 13, end: 17, substring: '<' }, + { type: 'text-reference', index: 0, start: 17, end: 22, substring: '&' }, + { type: 'text-plaintext', index: 0, start: 22, end: 24, substring: '--' }, + { type: 'text-reference', index: 0, start: 24, end: 28, substring: '>' }, + { type: 'text-reference', index: 0, start: 28, end: 34, substring: ''' }, + { type: 'text-reference', index: 0, start: 34, end: 40, substring: '"' }, + { type: 'text-plaintext', index: 0, start: 40, end: 42, substring: '--' }, + { type: 'text-reference', index: 0, start: 42, end: 50, substring: '}' }, + { type: 'text-end', index: 0, start: 50, end: 50, substring: '' }, + { type: 'end-tag-open', index: 0, start: 50, end: 52, substring: '' }, + ]; + const tokens = html`
{--<&-->'"--}
`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('accepts references in replaceable character data for special syntax', () => { + const expectedTokens = [ + { type: 'text-start', index: 0, start: 0, end: 0, substring: '' }, + { type: 'text-reference', index: 0, start: 0, end: 5, substring: '&' }, + { type: 'text-reference', index: 0, start: 5, end: 9, substring: '<' }, + { type: 'text-reference', index: 0, start: 9, end: 13, substring: '>' }, + { type: 'text-reference', index: 0, start: 13, end: 19, substring: '"' }, + { type: 'text-reference', index: 0, start: 19, end: 25, substring: ''' }, + { type: 'text-end', index: 0, start: 25, end: 25, substring: '' }, + ]; + const tokens = html`&<>"'`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('accepts references for commonly-used characters', () => { + const expectedTokens = [ + { type: 'text-start', index: 0, start: 0, end: 0, substring: '' }, + { type: 'text-reference', index: 0, start: 0, end: 6, substring: ' ' }, + { type: 'text-reference', index: 0, start: 6, end: 13, substring: '‘' }, + { type: 'text-reference', index: 0, start: 13, end: 20, substring: '’' }, + { type: 'text-reference', index: 0, start: 20, end: 27, substring: '“' }, + { type: 'text-reference', index: 0, start: 27, end: 34, substring: '”' }, + { type: 'text-reference', index: 0, start: 34, end: 41, substring: '–' }, + { type: 'text-reference', index: 0, start: 41, end: 48, substring: '—' }, + { type: 'text-reference', index: 0, start: 48, end: 56, substring: '…' }, + { type: 'text-reference', index: 0, start: 56, end: 62, substring: '•' }, + { type: 'text-reference', index: 0, start: 62, end: 70, substring: '·' }, + { type: 'text-reference', index: 0, start: 70, end: 78, substring: '†' }, + { type: 'text-end', index: 0, start: 78, end: 78, substring: '' }, + ]; + const tokens = html` ‘’“”–—…•·†`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('accepts references in attribute values', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 4, substring: 'div' }, + { type: 'start-tag-space', index: 0, start: 4, end: 5, substring: ' ' }, + { type: 'attribute-name', index: 0, start: 5, end: 8, substring: 'foo' }, + { type: 'start-tag-equals', index: 0, start: 8, end: 9, substring: '=' }, + { type: 'start-tag-quote', index: 0, start: 9, end: 10, substring: '"' }, + { type: 'attribute-value-start', index: 0, start: 10, end: 10, substring: '' }, + { type: 'attribute-value-plaintext', index: 0, start: 10, end: 12, substring: '--' }, + { type: 'attribute-value-reference', index: 0, start: 12, end: 18, substring: '{' }, + { type: 'attribute-value-reference', index: 0, start: 18, end: 22, substring: '<' }, + { type: 'attribute-value-reference', index: 0, start: 22, end: 27, substring: '&' }, + { type: 'attribute-value-reference', index: 0, start: 27, end: 31, substring: '>' }, + { type: 'attribute-value-reference', index: 0, start: 31, end: 37, substring: ''' }, + { type: 'attribute-value-reference', index: 0, start: 37, end: 43, substring: '"' }, + { type: 'attribute-value-reference', index: 0, start: 43, end: 51, substring: '}' }, + { type: 'attribute-value-plaintext', index: 0, start: 51, end: 53, substring: '--' }, + { type: 'attribute-value-end', index: 0, start: 53, end: 53, substring: '' }, + { type: 'start-tag-quote', index: 0, start: 53, end: 54, substring: '"' }, + { type: 'start-tag-close', index: 0, start: 54, end: 55, substring: '>' }, + { type: 'end-tag-open', index: 0, start: 55, end: 57, substring: '' }, + ]; + const tokens = html`
`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('accepts named references which require surrogate pairs', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 4, substring: 'div' }, + { type: 'start-tag-close', index: 0, start: 4, end: 5, substring: '>' }, + { type: 'text-start', index: 0, start: 5, end: 5, substring: '' }, + { type: 'text-plaintext', index: 0, start: 5, end: 7, substring: '--' }, + { type: 'text-reference', index: 0, start: 7, end: 13, substring: '𝕓' }, + { type: 'text-reference', index: 0, start: 13, end: 19, substring: '𝕓' }, + { type: 'text-plaintext', index: 0, start: 19, end: 21, substring: '--' }, + { type: 'text-reference', index: 0, start: 21, end: 27, substring: '𝕓' }, + { type: 'text-plaintext', index: 0, start: 27, end: 29, substring: '--' }, + { type: 'text-end', index: 0, start: 29, end: 29, substring: '' }, + { type: 'end-tag-open', index: 0, start: 29, end: 31, substring: '' }, + ]; + const tokens = html`
--𝕓𝕓--𝕓--
`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('leaves malformed references as-is', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 4, substring: 'div' }, + { type: 'start-tag-close', index: 0, start: 4, end: 5, substring: '>' }, + { type: 'text-start', index: 0, start: 5, end: 5, substring: '' }, + { type: 'text-plaintext', index: 0, start: 5, end: 7, substring: '--' }, + { type: 'text-reference', index: 0, start: 7, end: 12, substring: '&:^);' }, + { type: 'text-plaintext', index: 0, start: 12, end: 14, substring: '--' }, + { type: 'text-end', index: 0, start: 14, end: 14, substring: '' }, + { type: 'end-tag-open', index: 0, start: 14, end: 16, substring: '' }, + ]; + const tokens = htmlol`
--&:^);--
`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); +}); + +describe('JS-y escapes / encodings', () => { + it('properly encoded JS escape characters work', () => { + // Just checks that no errors are thrown. + html` + The \n is a newline. + The \r is a return. + The ', ", and ` characters are quotes and back ticks. + This \ is a literal backslash. + The \t character is a tab. + The \b is a backspace. + The \f is a form feed. + The \v character is a vertical tab. + The \u2026 character is an ellipsis (…). + The \x8230 character is also an ellipsis (…). + The \0 character is the nul character. + The ${interpolation} character is used to work around interpolations. + `; + }); +}); + +describe('attributes and properties', () => { + it('unbound attributes are reported', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 4, substring: 'div' }, + { type: 'start-tag-space', index: 0, start: 4, end: 5, substring: ' ' }, + { type: 'attribute-name', index: 0, start: 5, end: 6, substring: 'f' }, + { type: 'start-tag-equals', index: 0, start: 6, end: 7, substring: '=' }, + { type: 'start-tag-quote', index: 0, start: 7, end: 8, substring: '"' }, + { type: 'attribute-value-start', index: 0, start: 8, end: 8, substring: '' }, + { type: 'attribute-value-plaintext', index: 0, start: 8, end: 9, substring: 'b' }, + { type: 'attribute-value-end', index: 0, start: 9, end: 9, substring: '' }, + { type: 'start-tag-quote', index: 0, start: 9, end: 10, substring: '"' }, + { type: 'start-tag-close', index: 0, start: 10, end: 11, substring: '>' }, + { type: 'end-tag-open', index: 0, start: 11, end: 13, substring: '' }, + ]; + const tokens = html`
`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('bound attributes are reported', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 4, substring: 'div' }, + { type: 'start-tag-space', index: 0, start: 4, end: 5, substring: ' ' }, + { type: 'bound-attribute-name', index: 0, start: 5, end: 9, substring: 'attr' }, + { type: 'start-tag-equals', index: 0, start: 9, end: 10, substring: '=' }, + { type: 'start-tag-quote', index: 0, start: 10, end: 11, substring: '"' }, + { type: 'bound-attribute-value', index: 0, start: 11, end: 11, substring: '' }, + { type: 'start-tag-quote', index: 1, start: 0, end: 1, substring: '"' }, + { type: 'start-tag-close', index: 1, start: 1, end: 2, substring: '>' }, + { type: 'end-tag-open', index: 1, start: 2, end: 4, substring: '' }, + ]; + const tokens = html`
`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + // It’s also a good test that this is at the _end_ of the opening tag. If we + // change this, we should write another test to separately check that. + it('unbound boolean attributes are reported', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 4, substring: 'div' }, + { type: 'start-tag-space', index: 0, start: 4, end: 5, substring: ' ' }, + { type: 'boolean-name', index: 0, start: 5, end: 8, substring: 'foo' }, + { type: 'start-tag-close', index: 0, start: 8, end: 9, substring: '>' }, + { type: 'end-tag-open', index: 0, start: 9, end: 11, substring: '' }, + ]; + const tokens = html`
`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('bound boolean attributes are reported', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 4, substring: 'div' }, + { type: 'start-tag-space', index: 0, start: 4, end: 5, substring: ' ' }, + { type: 'bound-boolean-prefix', index: 0, start: 5, end: 6, substring: '?' }, + { type: 'bound-boolean-name', index: 0, start: 6, end: 9, substring: 'foo' }, + { type: 'start-tag-equals', index: 0, start: 9, end: 10, substring: '=' }, + { type: 'start-tag-quote', index: 0, start: 10, end: 11, substring: '"' }, + { type: 'bound-boolean-value', index: 0, start: 11, end: 11, substring: '' }, + { type: 'start-tag-quote', index: 1, start: 0, end: 1, substring: '"' }, + { type: 'start-tag-close', index: 1, start: 1, end: 2, substring: '>' }, + { type: 'end-tag-open', index: 1, start: 2, end: 4, substring: '' }, + ]; + const tokens = html`
`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('bound defined attributes are reported', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 4, substring: 'div' }, + { type: 'start-tag-space', index: 0, start: 4, end: 5, substring: ' ' }, + { type: 'bound-defined-prefix', index: 0, start: 5, end: 7, substring: '??' }, + { type: 'bound-defined-name', index: 0, start: 7, end: 10, substring: 'foo' }, + { type: 'start-tag-equals', index: 0, start: 10, end: 11, substring: '=' }, + { type: 'start-tag-quote', index: 0, start: 11, end: 12, substring: '"' }, + { type: 'bound-defined-value', index: 0, start: 12, end: 12, substring: '' }, + { type: 'start-tag-quote', index: 1, start: 0, end: 1, substring: '"' }, + { type: 'start-tag-close', index: 1, start: 1, end: 2, substring: '>' }, + { type: 'end-tag-open', index: 1, start: 2, end: 4, substring: '' }, + ]; + const tokens = html`
`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('unbound “on*” attributes as event handlers work', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 4, substring: 'div' }, + { type: 'start-tag-space', index: 0, start: 4, end: 5, substring: ' ' }, + { type: 'attribute-name', index: 0, start: 5, end: 12, substring: 'onclick' }, + { type: 'start-tag-equals', index: 0, start: 12, end: 13, substring: '=' }, + { type: 'start-tag-quote', index: 0, start: 13, end: 14, substring: '"' }, + { type: 'attribute-value-start', index: 0, start: 14, end: 14, substring: '' }, + { type: 'attribute-value-plaintext', index: 0, start: 14, end: 34, substring: 'this.textContent = \'' }, + { type: 'attribute-value-reference', index: 0, start: 34, end: 42, substring: '…' }, + { type: 'attribute-value-plaintext', index: 0, start: 42, end: 44, substring: 'hi' }, + { type: 'attribute-value-reference', index: 0, start: 44, end: 50, substring: '\' }, + { type: 'attribute-value-plaintext', index: 0, start: 50, end: 57, substring: 'u2026\';' }, + { type: 'attribute-value-end', index: 0, start: 57, end: 57, substring: '' }, + { type: 'start-tag-quote', index: 0, start: 57, end: 58, substring: '"' }, + { type: 'start-tag-close', index: 0, start: 58, end: 59, substring: '>' }, + { type: 'end-tag-open', index: 0, start: 59, end: 61, substring: '' }, + ]; + const tokens = html`
`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('properties are reported', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 4, substring: 'div' }, + { type: 'start-tag-space', index: 0, start: 4, end: 5, substring: ' ' }, + { type: 'bound-property-prefix', index: 0, start: 5, end: 6, substring: '.' }, + { type: 'bound-property-name', index: 0, start: 6, end: 10, substring: 'prop' }, + { type: 'start-tag-equals', index: 0, start: 10, end: 11, substring: '=' }, + { type: 'start-tag-quote', index: 0, start: 11, end: 12, substring: '"' }, + { type: 'bound-property-value', index: 0, start: 12, end: 12, substring: '' }, + { type: 'start-tag-quote', index: 1, start: 0, end: 1, substring: '"' }, + { type: 'start-tag-close', index: 1, start: 1, end: 2, substring: '>' }, + { type: 'end-tag-open', index: 1, start: 2, end: 4, substring: '' }, + ]; + const tokens = html`
`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); +}); + +describe('content interpolation', () => { + it('solo interpolation works', () => { + const expectedTokens = [ + { type: 'bound-content-value', index: 0, start: 0, end: 0, substring: '' }, + ]; + const tokens = html`${VALUE}`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('adjacent interpolations work', () => { + const expectedTokens = [ + { type: 'bound-content-value', index: 0, start: 0, end: 0, substring: '' }, + { type: 'bound-content-value', index: 1, start: 0, end: 0, substring: '' }, + ]; + const tokens = html`${VALUE}${VALUE}`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); +}); + +describe('odds and ends', () => { + it('surprisingly-accepted characters work', () => { + const expectedTokens = [ + { type: 'text-start', index: 0, start: 0, end: 0, substring: '' }, + { type: 'text-plaintext', index: 0, start: 0, end: 9, substring: '>\'"&& & &' }, + { type: 'text-end', index: 0, start: 9, end: 9, substring: '' }, + { type: 'start-tag-open', index: 0, start: 9, end: 10, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 10, end: 13, substring: 'div' }, + { type: 'start-tag-close', index: 0, start: 13, end: 14, substring: '>' }, + { type: 'end-tag-open', index: 0, start: 14, end: 16, substring: '' }, + { type: 'text-start', index: 0, start: 20, end: 20, substring: '' }, + { type: 'text-plaintext', index: 0, start: 20, end: 21, substring: '&' }, + { type: 'text-end', index: 0, start: 21, end: 21, substring: '' }, + ]; + const tokens = html`>'"&& & &
&`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('elements with "/" characters in attributes work', () => { + const expectedTokens = [ + { type: 'text-start', index: 0, start: 0, end: 0, substring: '' }, + { type: 'text-plaintext', index: 0, start: 0, end: 7, substring: '\n ' }, + { type: 'text-end', index: 0, start: 7, end: 7, substring: '' }, + { type: 'start-tag-open', index: 0, start: 7, end: 8, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 8, end: 9, substring: 'a' }, + { type: 'start-tag-space', index: 0, start: 9, end: 18, substring: '\n ' }, + { type: 'attribute-name', index: 0, start: 18, end: 22, substring: 'href' }, + { type: 'start-tag-equals', index: 0, start: 22, end: 23, substring: '=' }, + { type: 'start-tag-quote', index: 0, start: 23, end: 24, substring: '"' }, + { type: 'attribute-value-start', index: 0, start: 24, end: 24, substring: '' }, + { type: 'attribute-value-plaintext', index: 0, start: 24, end: 60, substring: 'https://github.com/Netflix/x-element' }, + { type: 'attribute-value-end', index: 0, start: 60, end: 60, substring: '' }, + { type: 'start-tag-quote', index: 0, start: 60, end: 61, substring: '"' }, + { type: 'start-tag-close', index: 0, start: 61, end: 62, substring: '>' }, + { type: 'text-start', index: 0, start: 62, end: 62, substring: '' }, + { type: 'text-plaintext', index: 0, start: 62, end: 86, substring: '\n click me\n ' }, + { type: 'text-end', index: 0, start: 86, end: 86, substring: '' }, + { type: 'end-tag-open', index: 0, start: 86, end: 88, substring: '' }, + { type: 'text-start', index: 0, start: 90, end: 90, substring: '' }, + { type: 'text-plaintext', index: 0, start: 90, end: 95, substring: '\n ' }, + { type: 'text-end', index: 0, start: 95, end: 95, substring: '' }, + ]; + // Note the "/" character. + const tokens = html` + + click me + + `; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('elements with "<" or ">" characters in attributes work', () => { + const expectedTokens = [ + { type: 'text-start', index: 0, start: 0, end: 0, substring: '' }, + { type: 'text-plaintext', index: 0, start: 0, end: 7, substring: '\n ' }, + { type: 'text-end', index: 0, start: 7, end: 7, substring: '' }, + { type: 'start-tag-open', index: 0, start: 7, end: 8, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 8, end: 9, substring: 'a' }, + { type: 'start-tag-space', index: 0, start: 9, end: 18, substring: '\n ' }, + { type: 'attribute-name', index: 0, start: 18, end: 26, substring: 'data-foo' }, + { type: 'start-tag-equals', index: 0, start: 26, end: 27, substring: '=' }, + { type: 'start-tag-quote', index: 0, start: 27, end: 28, substring: '"' }, + { type: 'attribute-value-start', index: 0, start: 28, end: 28, substring: '' }, + { type: 'attribute-value-plaintext', index: 0, start: 28, end: 38, substring: '<><>' }, + { type: 'attribute-value-end', index: 0, start: 38, end: 38, substring: '' }, + { type: 'start-tag-quote', index: 0, start: 38, end: 39, substring: '"' }, + { type: 'start-tag-space', index: 0, start: 39, end: 48, substring: '\n ' }, + { type: 'attribute-name', index: 0, start: 48, end: 52, substring: 'href' }, + { type: 'start-tag-equals', index: 0, start: 52, end: 53, substring: '=' }, + { type: 'start-tag-quote', index: 0, start: 53, end: 54, substring: '"' }, + { type: 'attribute-value-start', index: 0, start: 54, end: 54, substring: '' }, + { type: 'attribute-value-plaintext', index: 0, start: 54, end: 90, substring: 'https://github.com/Netflix/x-element' }, + { type: 'attribute-value-end', index: 0, start: 90, end: 90, substring: '' }, + { type: 'start-tag-quote', index: 0, start: 90, end: 91, substring: '"' }, + { type: 'start-tag-close', index: 0, start: 91, end: 92, substring: '>' }, + { type: 'text-start', index: 0, start: 92, end: 92, substring: '' }, + { type: 'text-plaintext', index: 0, start: 92, end: 116, substring: '\n click me\n ' }, + { type: 'text-end', index: 0, start: 116, end: 116, substring: '' }, + { type: 'end-tag-open', index: 0, start: 116, end: 118, substring: '' }, + { type: 'text-start', index: 0, start: 120, end: 120, substring: '' }, + { type: 'text-plaintext', index: 0, start: 120, end: 125, substring: '\n ' }, + { type: 'text-end', index: 0, start: 125, end: 125, substring: '' }, + ]; + // Note the "/", "<", and ">" characters. + const tokens = html` + + click me + + `; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('multiple opening and closing tags work', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 4, substring: 'div' }, + { type: 'start-tag-close', index: 0, start: 4, end: 5, substring: '>' }, + { type: 'start-tag-open', index: 0, start: 5, end: 6, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 6, end: 9, substring: 'div' }, + { type: 'start-tag-close', index: 0, start: 9, end: 10, substring: '>' }, + { type: 'end-tag-open', index: 0, start: 10, end: 12, substring: '' }, + { type: 'end-tag-open', index: 0, start: 16, end: 18, substring: '' }, + ]; + const tokens = html`
`; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('void elements work', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 6, substring: 'input' }, + { type: 'start-tag-space', index: 0, start: 6, end: 7, substring: ' ' }, + { type: 'attribute-name', index: 0, start: 7, end: 11, substring: 'type' }, + { type: 'start-tag-equals', index: 0, start: 11, end: 12, substring: '=' }, + { type: 'start-tag-quote', index: 0, start: 12, end: 13, substring: '"' }, + { type: 'attribute-value-start', index: 0, start: 13, end: 13, substring: '' }, + { type: 'attribute-value-plaintext', index: 0, start: 13, end: 21, substring: 'checkbox' }, + { type: 'attribute-value-end', index: 0, start: 21, end: 21, substring: '' }, + { type: 'start-tag-quote', index: 0, start: 21, end: 22, substring: '"' }, + { type: 'start-tag-space', index: 0, start: 22, end: 23, substring: ' ' }, + { type: 'bound-attribute-name', index: 0, start: 23, end: 28, substring: 'value' }, + { type: 'start-tag-equals', index: 0, start: 28, end: 29, substring: '=' }, + { type: 'start-tag-quote', index: 0, start: 29, end: 30, substring: '"' }, + { type: 'bound-attribute-value', index: 0, start: 30, end: 30, substring: '' }, + { type: 'start-tag-quote', index: 1, start: 0, end: 1, substring: '"' }, + { type: 'void-tag-close', index: 1, start: 1, end: 2, substring: '>' }, + ]; + const tokens = html``; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('textarea elements work', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 9, substring: 'textarea' }, + { type: 'start-tag-close', index: 0, start: 9, end: 10, substring: '>' }, + { type: 'text-start', index: 0, start: 10, end: 10, substring: '' }, + { type: 'text-plaintext', index: 0, start: 10, end: 31, substring: 'this is the ' }, + { type: 'text-reference', index: 0, start: 31, end: 38, substring: '“' }, + { type: 'text-plaintext', index: 0, start: 38, end: 45, substring: 'default' }, + { type: 'text-reference', index: 0, start: 45, end: 52, substring: '”' }, + { type: 'text-plaintext', index: 0, start: 52, end: 58, substring: ' value' }, + { type: 'text-end', index: 0, start: 58, end: 58, substring: '' }, + { type: 'end-tag-open', index: 0, start: 58, end: 60, substring: '' }, + ]; + const tokens = html``; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('textarea elements with strict interpolation work', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 9, substring: 'textarea' }, + { type: 'start-tag-close', index: 0, start: 9, end: 10, substring: '>' }, + { type: 'bound-text-value', index: 0, start: 10, end: 10, substring: '' }, + { type: 'end-tag-open', index: 1, start: 0, end: 2, substring: '' }, + ]; + const tokens = html``; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('custom elements work', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 8, substring: 'foo-bar' }, + { type: 'start-tag-close', index: 0, start: 8, end: 9, substring: '>' }, + { type: 'end-tag-open', index: 0, start: 9, end: 11, substring: '' }, + ]; + const tokens = html``; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); + + it('template elements work', () => { + const expectedTokens = [ + { type: 'start-tag-open', index: 0, start: 0, end: 1, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 1, end: 9, substring: 'template' }, + { type: 'start-tag-close', index: 0, start: 9, end: 10, substring: '>' }, + { type: 'start-tag-open', index: 0, start: 10, end: 11, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 11, end: 14, substring: 'div' }, + { type: 'start-tag-close', index: 0, start: 14, end: 15, substring: '>' }, + { type: 'start-tag-open', index: 0, start: 15, end: 16, substring: '<' }, + { type: 'start-tag-name', index: 0, start: 16, end: 17, substring: 'p' }, + { type: 'start-tag-close', index: 0, start: 17, end: 18, substring: '>' }, + { type: 'end-tag-open', index: 0, start: 18, end: 20, substring: '' }, + { type: 'end-tag-open', index: 0, start: 22, end: 24, substring: '' }, + { type: 'end-tag-open', index: 0, start: 28, end: 30, substring: '' }, + ]; + const tokens = html``; + assert(deepEqual(tokens, expectedTokens), stringifyTokens(tokens)); + }); +}); + +describe('errors', () => { + it('throws when markup after end tag cannot be parsed', () => { + const callback = () => htmlol`
<`; + const expectedMessage = '[#110]'; + assertThrows(callback, expectedMessage, { startsWith: true }); + }); + + it('throws when attempting non-trivial interpolation of a textarea tag (preceding space)', () => { + const callback = () => html``; + const expectedMessage = '[#155]'; + assertThrows(callback, expectedMessage, { startsWith: true }); + }); + + it('throws when attempting non-trivial interpolation of a textarea tag (succeeding space)', () => { + const callback = () => html``; + const expectedMessage = '[#155]'; + assertThrows(callback, expectedMessage, { startsWith: true }); + }); + + it('throws when attempting non-trivial interpolation of a textarea tag', () => { + const callback = () => html``; + const expectedMessage = '[#155]'; + assertThrows(callback, expectedMessage, { startsWith: true }); + }); + + it('throws when attempting non-trivial interpolation of a textarea tag via nesting', () => { + const callback = () => html``; + const expectedMessage = '[#155]'; + assertThrows(callback, expectedMessage, { startsWith: true }); + }); + + it('throws when attempting non-trivial interpolation of a textarea tag via nesting', () => { + const callback = () => html``; + const expectedMessage = '[#155]'; + assertThrows(callback, expectedMessage, { startsWith: true }); + }); + + it('throws when interpolation of a textarea is at the end of the template', () => { + const callback = () => html``; + const expectedMessage = '[#155]'; + assertThrows(callback, expectedMessage, { startsWith: true }); + }); + + it('throws for declarative shadow root / shadowrootmode', () => { + const callback = () => htmlol`