mirror of https://github.com/odoo/owl.git synced 2025-10-06 19:59:41 +07:00

Files

T

History

Géry Debongnie 79ea50aab9 [FIX] compiler: throw if using t-slot on a htmlelement tag

Before this commit, the tagName of a `t-slot` directive was ignored. So,
<t t-slot="owl">...</t>  and <div t-slot="owl">...</div> were basically
equivalent.

This is not really acceptable, since it most likely hides a developer
error. So, the question is what to do about it? There are two obvious
solutions:

- either make the `t-slot` directive behave as t-esc: the above example
would then be equivalent to <div><t t-slot="owl">...</t></div>
- or throw an error.

However, the first solution seems to be ambiguous when using a component
with slot props. How should the following code be interpreted?
   <SomeComponent a="a" b="b" t-slot="owl"/>
Should the 'a' and 'b' props be considered props for the component or
for the slot?

I guess we could make an exception for components, but it seems more
complicated than what it should be. Because of that, it seems simpler to
just throw an error.

closes #1354

2023-03-05 09:04:42 +01:00

learning

[FIX] t-call-context: make this unavailable in rendering context

2023-01-12 09:38:22 +01:00

miscellaneous

[DOC] add explanation on structure of compiled template

2022-03-01 15:46:09 +01:00

reference

[FIX] compiler: throw if using t-slot on a htmlelement tag

2023-03-05 09:04:42 +01:00

readme.md

[IMP] misc: export the validate function

2022-05-24 13:52:42 +02:00

readme.md

🦉 Owl overview 🦉

Here is a list of everything exported by the Owl library:

Main entities:

App: represent an Owl application (mainly a root component,a set of templates, and a config)
Component: the main class to define a concrete Owl component
mount: main entry point for most application: mount a component to a target
xml: helper to define an inline template

Reactivity

useState: create a reactive object (hook, linked to a specific component)
reactive: create a reactive object (not linked to any component)
markRaw: mark an object or array so that it is ignored by the reactivity system
toRaw: given a reactive objet, return the raw (non reactive) underlying object

Lifecycle hooks:

onWillStart: hook to define asynchronous code that should be executed before component is rendered
onMounted: hook to define code that should be executed when component is mounted
onWillPatch: hook to define code that should be executed before component is patched
onWillUpdateProps: hook to define code that should be executed before component is updated
onPatched: hook to define code that should be executed when component is patched
onWillRender: hook to define code that should be executed before component is rendered
onRendered: hook to define code that should be executed after component is rendered
onWillUnmount: hook to define code that should be executed before component is unmounted
onWillDestroy: hook to define code that should be executed before component is destroyed
onError: hook to define a Owl error handler

Other hooks:

useComponent: return a reference to the current component (useful to create derived hooks)
useEffect: define an effect with its dependencies
useEnv: return a reference to the current env
useExternalListener: add a listener outside of a component DOM
useRef: get an object representing a reference (t-ref)
useChildSubEnv: extend the current env with additional information (for child components)
useSubEnv: extend the current env with additional information (for current component and child components)

Utility/helpers:

EventBus: a simple event bus
loadFile: an helper to load a file from the server
markup: utility function to define strings that represent html (should not be escaped)
status: utility function to get the status of a component (new, mounted or destroyed)
validate: validates if an object satisfies a specified schema
whenReady: utility function to execute code when DOM is ready