Index
12 index found 1275 pages: 13 interfacing with the xpcom cycle collector firefox 3, xpcom this is a quick overview of the cycle collector introduced into xpcom for firefox 3, including a description of the steps involved in modifying an existing c++ class to participate in xpcom cycle collection.
... 37 components.utils.forcegc needscontent, xpcom, xpcom:language bindings, xpconnect components.utils.forcegc lets scripts force a garbage collection cycle.
...in this case it can be important to be able to force a garbage collection cycle from javascript.
...And 3 more matches

Components.utils
forcegc() forces a garbage collection cycle.
... forcecc() forces a cycle collection cycle.
... forceshrinkinggc() forces a shrinking garbage collection cycle.
...And 3 more matches

IAccessibleText
once the handler has returned, the validity of the data depends on how the server manages the life cycle of its objects.
... also, note that the server may have different life cycle management strategies for controls depending on whether or not a control manages its children.
...servers should document their life cycle strategy as this will be of interest to assistive technology or script engines accessing data out of process or from other threads.
...And 3 more matches

WebIDL bindings
adding webidl bindings to a class to add a webidl binding for interface myinterface to a class mozilla::dom::myinterface that's supposed to implement that interface, you need to do the following: if your interface doesn't inherit from any other interfaces, inherit from nswrappercache and hook up the class to the cycle collector so it will trace the wrapper cache properly.
... if you do need to hook up cycle collection, it will look like this in the common case of also inheriting from nsisupports: // add strong pointers your class holds here.
... if you do, change to using // ns_impl_cycle_collection_wrappercache.
...And 3 more matches

Space Manager Detailed Design - Archive of obsolete content
mbandlist; // header/sentinel for circular linked list of band rects frameinfo* mframeinfomap; nsintervalset mfloatdamage; static print32 scachedspacemanagercount; static void* scachedspacemanagers[ns_space_manager_cache_size]; nsspacemanager(const nsspacemanager&); // no implementation void operator=(const nsspacemanager&); // no implementation }; public api life cycle the constructor requires a presentation shell, used for arena allocations mostly, and a frame that this space manager is rooted on.
... nsspacemanager(nsipresshell* apresshell, nsiframe* aframe); ~nsspacemanager(); operators 'new' and 'delete' are overridden to support a recycler.
... space manager instances come and go pretty frequently, and this recycler prevents excessive heap allocations and the performance penalties associated with it.
...And 2 more matches

Framework main features - Learn web development
lifecycle in the context of a framework, a component’s lifecycle is a collection of phases a component goes through from the time it is rendered by the browser (often called mounting) to the time that it is removed from the dom (often called unmounting).
... each framework names these lifecycle phases differently, and not all give developers access to the same phases.
... this diagram of a react component's lifecycle offers a general overview of the concept.
...And 2 more matches

Leak-hunting strategies and tips
build with --enable-trace-malloc common leak patterns when trying to find a leak of reference-counted objects, there are a number of patterns that could cause the leak: ownership cycles.
... the most common source of hard-to-fix leaks is ownership cycles.
... if you can avoid creating cycles in the first place, please do, since it's often hard to be sure to break the cycle in every last case.
...And 2 more matches

Invariants
(the jsval encoding depends on this.) the jsstackframe::down chain never forms a cycle.
... but note that a stack frame is not necessarily newer than the next stack frame down, thanks to generators!) an object's scope chain (found by chasing jsobject::fslots[jsslot_parent]) never forms a cycle.
...even if the function is native, there is serious trouble: js_newobject with null parent argument calculates the parent from cx->fp->scopechain, which can be stale if we're on trace.) the chain of properties starting at any jsshape and chasing jsshape::parent never forms a cycle and does not contain any duplicate jsscopeproperty::slot values other than -1.
...And 2 more matches

JS_SetGCCallback
during each complete garbage collection cycle, the current gc callback is called four times: jsgc_begin start of gc.
...sometimes several gc cycles happen in a row, so jsgc_begin is followed by alternating jsgc_mark_end and jsgc_finalize_end callbacks, followed at last by jsgc_end.
...but the javascript engine will then detect that gc is already happening and will not actually do a nested gc cycle in this case.
...And 2 more matches

nsINavHistoryResultViewObserver
inherits from: nsisupports last changed in gecko 1.9.0 method overview boolean candrop(in long index, in long orientation); void ondrop(in long row, in long orientation); void ontoggleopenstate(in long index); void oncycleheader(in nsitreecolumn column); void oncyclecell(in long row, in nsitreecolumn column); void onselectionchanged(); void onperformaction(in wstring action); void onperformactiononrow(in wstring action, in long row); void onperformactiononcell(in wstring action, in long row, in nsitreecolumn column); constants constant value descript...
... oncycleheader() called when a header is clicked.
... void oncycleheader( in nsitreecolumn column ); parameters column the column whose header was clicked.
...And 2 more matches

nsITreeView
method overview boolean candrop(in long index, in long orientation, in nsidomdatatransfer datatransfer); boolean candropbeforeafter(in long index, in boolean before); obsolete since gecko 1.8 boolean candropon(in long index); obsolete since gecko 1.8 void cyclecell(in long row, in nsitreecolumn col); void cycleheader(in nsitreecolumn col); void drop(in long row, in long orientation, in nsidomdatatransfer datatransfer); astring getcellproperties(in long row, in nsitreecolumn col, in nsisupportsarray properties obsolete since gecko 22); astring getcelltext(in long row, in nsitreecolumn col); astring getcellvalu...
... cyclecell() called on the view when a cell in a non-selectable cycling column (for example, unread/flag/and so on.) is clicked.
... void cyclecell( in long row, in nsitreecolumn col ); parameters row the row of the cell.
...And 2 more matches

Debugger.Memory - Firefox Developer Tools
ongarbagecollection(statistics) a garbage collection cycle spanning one or more debuggees has just been completed.
... the statistics parameter is an object containing information about the gc cycle.
...because spidermonkey’s collector is incremental, a full collection cycle may consist of multiple discrete collection slices with the js mutator running interleaved.
...And 2 more matches

Using custom elements - Web Components
it is possible to define specific lifecycle callbacks inside the class, which run at specific points in the element's lifecycle.
... you'll learn more about these in the using the lifecycle callbacks section below.
... using the lifecycle callbacks you can define several different callbacks inside a custom element's class definition, which fire at different points in the element's lifecycle: connectedcallback: invoked each time the custom element is appended into a document-connected element.
...And 2 more matches

Reviewer Checklist
in c++, cycle-collect as needed.
... if javascript can see your object, it probably needs to be cycle-collected.
... [fennec: all view methods should be touched only on ui thread.] [fennec: activity lifecycle awareness (works with "never keep activities").
... consider adding prefs to disable the feature entirely in case bugs are found later in the release cycle.

Displaying Places information using views
be careful about reference cycles.
...for these objects to be freed during javascript garbage collection, you must clear this cycle by calling result.removeobserver(view).
... return this._getcelltext(arowindex, acol); }; view._cycleheader = view.cycleheader; view.cycleheader = function (acol) { switch (acol.id || acol.element.getattribute("anonid")) { case "fulluri": case "indexinparent": case "parity": // you might resort by column here.
... break; default: this._cycleheader(acol); break; } }; // execute a query and gets its result.

PerfMeasurement.jsm
variable type description cpu_cycles uint64 the number of cpu cycles elapsed.
... bus_cycles uint64 the number of memory bus cycles that elapsed.
... constant value description cpu_cycles 0x00000001 measure cpu cycles elapsed.
... bus_cycles 0x00000040 measure the number of bus cycles elapsed.

DMD
0 0.00% of the heap (16.85% cumulative) 0.02% of unreported (94.68% cumulative) allocated at { #01: replace_malloc (/home/njn/moz/mi5/go64dmd/memory/replace/dmd/../../../../memory/replace/dmd/dmd.cpp:1286) #02: malloc (/home/njn/moz/mi5/go64dmd/memory/build/../../../memory/build/replace_malloc.c:153) #03: moz_xmalloc (/home/njn/moz/mi5/memory/mozalloc/mozalloc.cpp:84) #04: nscyclecollectingautorefcnt::incr(void*, nscyclecollectionparticipant*) (/home/njn/moz/mi5/go64dmd/dom/xul/../../dist/include/nsisupportsimpl.h:250) #05: nsxulelement::create(nsxulprototypeelement*, nsidocument*, bool, bool,mozilla::dom::element**) (/home/njn/moz/mi5/dom/xul/nsxulelement.cpp:287) #06: nsxblcontentsink::createelement(char16_t const**, unsigned int, mozilla::dom::nodeinfo*, unsigne...
...for example: reported at { #01: mozilla::dmd::report(void const*) (/home/njn/moz/mi2/memory/replace/dmd/dmd.cpp:1740) 0x7f68652581ca #02: cyclecollectormallocsizeof(void const*) (/home/njn/moz/mi2/xpcom/base/nscyclecollector.cpp:3008) 0x7f6860fdfe02 #03: nspurplebuffer::sizeofexcludingthis(unsigned long (*)(void const*)) const (/home/njn/moz/mi2/xpcom/base/nscyclecollector.cpp:933) 0x7f6860fdb7af #04: nscyclecollector::sizeofincludingthis(unsigned long (*)(void const*), unsigned long*, unsigned long*, unsigned long*, unsigned long*, ...
...unsigned long*) const (/home/njn/moz/mi2/xpcom/base/nscyclecollector.cpp:3029) 0x7f6860fdb6b1 #05: cyclecollectormultireporter::collectreports(nsimemorymultireportercallback*, nsisupports*) (/home/njn/moz/mi2/xpcom/base/nscyclecollector.cpp:3075) 0x7f6860fde432 #06: nsmemoryinfodumper::dumpmemoryreportstofileimpl(nsastring_internal const&) (/home/njn/moz/mi2/xpcom/base/nsmemoryinfodumper.cpp:626) 0x7f6860fece79 #07: nsmemoryinfodumper::dumpmemoryreportstofile(nsastring_internal const&, bool, bool) (/home/njn/moz/mi2/xpcom/base/nsmemoryinfodumper.cpp:344) 0x7f6860febaf9 #08: mozilla::(anonymous namespace)::dumpmemoryreportsrunnable::run() (/home/njn/moz/mi2/xpcom/base/nsmemoryinfodumper.cpp:58) 0x7f6860fefe03 } you can tell which memory reporter made the report by the name of the mallo...
...in this case it was the cycle collector's reporter.

JS::PerfMeasurement
the current implementation can measure eleven different types of low-level hardware and software events: events that can be measured bitmask passed to constructor counter variable what it measures perfmeasurement::cpu_cycles .cpu_cycles raw cpu clock cycles ::instructions .instructions total instructions executed ::cache_references .cache_references total number of memory accesses ::cache_misses .cache_misses memory accesses that missed the cache ::branch_instructions .branch_instructions branch instructions executed ::bra...
...nch_misses .branch_misses branch instructions that were not predicted correctly ::bus_cycles .bus_cycles total memory bus cycles ::page_faults .page_faults total page-fault exceptions fielded by the os ::major_page_faults .major_page_faults page faults that required disk access ::context_switches .context_switches context switches involving the profiled thread ::cpu_migrations .cpu_migrations migrations of the profiled thread from one cpu core to another these events map directly to "generic events" in the linux 2.6.31+ <linux/perf_event.h> interface, and so unfortunately are a little vague in their specification; for instance, we can't tell you exactly which level of cache you get misses for if ...
... counter values are accumulated across many start/stop cycles, and you can modify their values if you want; stop simply adds counts read back from the os to whatever is already in each counter.
...uint64 cpu_cycles, uint64 instructions, etc.

JS_ContextIterator
cycles through the js contexts associated with a particular jsruntime.
...on success, the value of *iterp is modified so that repeated calls cycle through all the contexts in rt.
...each call to js_contextiterator returns the next context in the cycle.
... example the following code snippet illustrates how to cycle through the contexts for a given runtime: jscontext *acx; jscontext *iterp = null; int i = 0; while ((acx = js_contextiterator(rt, &iterp)) != null) { printf("%d ", ++i); } see also mxr id search for js_contextiterator ...

Components.utils.forceGC
components.utils.forcegc lets scripts force a garbage collection cycle.
...in this case it can be important to be able to force a garbage collection cycle from javascript.
... note: nsidomwindowutils.garbagecollect() offers similar functionality but will trigger the cycle collector in addition to the garbage collector in the javascript engine.
... this will make sure that xpcom components that build cycles with javascript objects also get collected which might be important, for example for testcases that depend on the garbage collector.

Language bindings
this is useful for privileged code, such as add-on code, to access variables and apis defined in web content.components.utils.exportfunctionthis function provides a safe way to expose a function from a privileged scope to a less-privileged scope.components.utils.forcegccomponents.utils.forcegc lets scripts force a garbage collection cycle.
...in this case it can be important to be able to force a garbage collection cycle from javascript.
...it is meant for use by extension developers who have exception handler blocks which want to "eat" an exception, but still want to report it to the console.components.utils.sandboxcomponents.utils.sandbox is used to create a sandbox object for use with evalinsandbox().components.utils.scheduleprecisegcthis method lets scripts schedule a garbage collection cycle.
... the garbage collection cycle will occur sometime in the future, when no javascript code is executing.

nsIDOMChromeWindow
inherits from: nsisupports last changed in gecko 2.0 (firefox 4 / thunderbird 3.3 / seamonkey 2.1) method overview void beginwindowmove(in nsidomevent mousedownevent); void getattention(); void getattentionwithcyclecount(in long acyclecount); void maximize(); void minimize(); void notifydefaultbuttonloaded(in nsidomelement defaultbutton); void restore(); void setcursor(in domstring cursor); attributes attribute type description browserdomwindow nsibrowserdomwindow the related nsibrowserdomwindow instance which provides access to yet another layer of utility functions by chrome script.
...getattentionwithcyclecount() same as getattention method excepting that this can specify the maximum number of times to animate the window per system conventions.
... void getattentionwithcyclecount( in long acyclecount ); parameters acyclecount the maximum number of times to animate the window per system conventions.
... if set to -1, cycles indefinitely until window is brought into the foreground.

Index - Web APIs
502 cache api, cache, cache api, experimental, interface, offline, reference, service workers, service worker api, storage the cache interface provides a storage mechanism for request / response object pairs that are cached, for example as part of the serviceworker life cycle.
...ous optional options that may affect the matching process; see matching event listeners for removal 1279 extendableevent api, experimental, extendableevent, interface, offline, reference, service workers, serviceworker, workers the extendableevent interface extends the lifetime of the install and activate events dispatched on the global scope as part of the service worker lifecycle.
...it builds up a clone by recursing through the input object while maintaining a map of previously visited references in order to avoid infinitely traversing cycles.
...the high-level guides listed below introduce webrtc technology from a top-down perspective, describing the overall architecture, the life cycle of a webrtc connection, and basic security and technological issues you might run into as you explore and build web content or apps using the webrtc api.

system - CSS: Cascading Style Sheets
cyclic cycles through the list of symbols provided.
... symbolic cycles through the provided list of symbols.
... on each successive pass through the cycle, the symbols used for the counter representation are doubled, tripled, and so on.
...if one more more counter styles defenitions form a cycle with their extends values, the browser will treat all the participating counter styles as extending from the decimal style.

Memory Management - JavaScript
memory life cycle regardless of the programming language, the memory life cycle is pretty much always the same: allocate the memory you need use the allocated memory (read, write) release the allocated memory when it is not needed anymore the second part is explicit in all languages.
...in the following example, two objects are created with properties that reference one another, thus creating a cycle.
...cycles are a common mistake that can generate memory leaks: var div; window.onload = function() { div = document.getelementbyid('mydivelement'); div.circularreference = div; div.lotsofdata = new array(10000).join('*'); }; in the above example, the dom element "mydivelement" has a circular reference to itself in the "circularreference" property.
... cycles are no longer a problem in the first example above, after the function call returns, the two objects are no longer referenced by any resource that is reachable from the global object.

treecol - Archive of obsolete content
attributes crop, cycler, dragging, editable, fixed, hidden, hideheader, ignoreincolumnpicker, label, primary, sort, sortactive, sortdirection, src, type, width properties accessibletype style classes treecol-image examples this example shows a checkbox in the first column, requires the style below.
...for example, for a menuitem in a menu you can add the following css rule when you want to use the value none: menupopup > menuitem, menupopup > menu { max-width: none; } cycler type: boolean if true, then the column is a cycler column.
...if the cycler attribute is not set, the cell is a regular text cell.

Practical positioning examples - Learn web development
then we use a for loop to cycle through all the tabs and run a function called settabhandler() on each one, which sets up the functionality that should occur when each one is clicked on.
... in the settabhandler() function, the tab has an onclick event handler set on it, so that when the tab is clicked, the following occurs: a for loop is used to cycle through all the tabs and remove any classes that are present on them.
... a for loop is used to cycle through all the panels and remove any classes that are present on them.

Working with Svelte stores - Learn web development
next we import the ondestroy() lifecycle function, which lets us execute a callback after the component has been unmounted.
... finally, with the ondestroy() lifecycle function, we make sure to call the cleartimeout() function.
...and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Client-side tooling overview - Learn web development
overview: understanding client-side tools next in this article we provide an overview of modern web tooling, what kinds of tools are available and where you’ll meet them in the lifecycle of web app development, and how to find help with individual tools.
... transformation this stage of your web app lifecycle typically allows you to code in either "future code" (such as the latest css or javascript features that might not have native support in browsers yet) or code using another language entirely, such as typescript.
... some thoughts about tooling types there's certainly an order in which the different tooling types apply in the development lifecycle, but rest assured that you don't have to have all of these in place to release a website.

Measuring performance using the PerfMeasurement.jsm code module
for instance, let's measure instructions executed, cache references, and cache misses: let monitor = new perfmeasurement(perfmeasurement.cpu_cycles | perfmeasurement.cache_references | perfmeasurement.cache_misses); this creates a new perfmeasurement object, configured to record the specified event types.
... the monitor object automatically accumulates counts over start/stop cycles (that is, it doesn't automatically zero the counters each time you start recording).
... when you're done benchmarking, you can read out each of the counters you asked for as properties: let report = "cpu cycles: " + monitor.cpu_cycles + "\n" + "cache refs: " + monitor.cache_references + "\n" + "cache misses: " + monitor.cache_misses + "\n"; monitor.reset(); alert(report); the reset() method clears all of the enabled counters, as you might expect.

TraceMalloc
leaksoup also finds sets of objects that are rooted by a cycle (i.e., a set of reference counted objects that own references to each other in a cycle).
... however, it cannot distinguish between owning and non-owning pointers, which means that non-owning pointers that are nulled out by destructors may show up in leaksoup as cycles.
...(a strongly connected component with only one node is listed as a single object.) any single object listed as a root is really a leak root, and any component listed as a root either (a) contains an object that is a root or (b) contains objects that form an ownership cycle that is a root.

Nonblocking IO In NSPR
the socket returned by <tt>pr_accept()</tt> or <tt>pr_acceptread()</tt> on a blocking, listening socket may be a recycled socket previously used in a <tt>pr_transmitfile()</tt> call.
... since <tt>pr_transmitfile()</tt> only operates in blocking mode, this recycled socket can only be reused in blocking mode, hence the above constraint.
... because these constraints only apply to nt, it is advised that you test your cross-platform code that uses nonblocking io on nt early in the development cycle.

GCIntegration - SpiderMonkey Redirect 1
at a high level, there are three issues to be aware of: interactions between the garbage collector and the cycle collector incremental garbage collection moving garbage collection the apis for gc/cc interaction and incremental gc are already in place.
...many pointers in gecko are traced via ns_decl_cycle_collection_script_holder_class and its related macros.
...as above, this means that classes governed by ns_decl_cycle_collection_script_holder_class do not need a write barrier on their fields.

Index
140 jsobjectops.setproto jsapi reference, obsolete, spidermonkey these hooks must check for cycles without deadlocking, and otherwise take special steps.
...each call to js_contextiterator returns the next context in the cycle.
...in this case the callback must be prepared to deal with cycles in the traversal graph.

Garbage collection
the mark bitmap has two bits per gc cell, so that it can represent both regular liveness marking ("marked black") as well as reachability from cycle-collected objects ("marked gray").
... implementation details write barriers have a runtime cost, so spidermonkey tries to skip them when an incremental gc cycle is not active.
...gray roots are used by the gecko cycle collector to find cycles that pass through the js heap.

JSAPI User Guide
in the case of js::value, the javascript garbage collector recycles objects, strings, and numbers that don't appear to be in use, and a js::value by itself does not protect its referent from the garbage collector.
...the life cycle of a jsscript looks like this: the application compiles some javascript code using js_compilescript, js_compileutf8file, or js_compilefilehandle.
...the life cycle of a script using this feature is like this: the application compiles some javascript code.

Gecko object attributes
note some widgets which appear to be checkboxes might in fact be cyclers (see "cycles" below).
... tree related attributes cycles "true" when the tree cell is a cycler, which means each click will cycle to the next option.
... in this case action 0 is called "cycles", which moves to the next option in the same way a manual click does.

IAccessibleTable
once the handler has returned, the validity of the data depends on how the server manages the life cycle of its objects.
... also, note that the server may have different life cycle management strategies for controls depending on whether or not a control manages its children.
...servers should document their life cycle strategy as this will be of interest to assistive technology or script engines accessing data out of process or from other threads.

IAccessibleTable2
once the handler has returned, the validity of the data depends on how the server manages the life cycle of its objects.
... also, note that the server may have different life cycle management strategies for controls depending on whether or not a control manages its children.
...servers should document their life cycle strategy as this will be of interest to assistive technology or script engines accessing data out of process or from other threads.

nsIDOMWindowUtils
an atrusted); nsidomelement elementfrompoint(in float ax, in float ay, in boolean aignorerootscrollframe, in boolean aflushlayout); void entermodalstate(); nsidomelement findelementwithviewid(in nsviewid aid); void focus(in nsidomelement aelement); void forceupdatenativemenuat(in astring indexstring); void garbagecollect([optional] in nsicyclecollectorlistener alistener); short getcursortype(); astring getdocumentmetadata(in astring aname); nsidomwindow getouterwindowwithid(in unsigned long long aouterwindowid); long getpccountscriptcount(); astring getpccountscriptsummary(in long ascript); astring getpccountscriptcontents(in long ascript); void getscrollxy(in b...
... void forceupdatenativemenuat( in astring indexstring ); parameters indexstring garbagecollect() force a garbage collection followed by a cycle collection.
... void garbagecollect( in nsicyclecollectorlistener alistener optional ); parameters alistener optional listener that receives information about the cc graph (see @mozilla.org/cycle-collector-logger;1 for a logger component) getcursortype() get current cursor type from this window.

Examine and edit HTML - Firefox Developer Tools
as you type, an autocomplete popup shows any class or id attributes that match the current search term: press up and down to cycle through suggestions, tab to choose the current suggestion, then enter to select the first node with that attribute.
... to cycle through matches, press enter.
... you can cycle backwards through matches using shift + enter.

Waterfall - Firefox Developer Tools
cycle collection reclaiming c++ reference-counted data structures.
...see kyle huey's blog post about cycle collection.
... cc graph reduction preparation/pre-optimization for cycle collection.

AudioNode.connect() - Web APIs
it is possible to connect an audionode to another audionode, which in turn connects back to the first audionode, creating a cycle.
... this is allowed only if there is at least one delaynode in the cycle.
... notsupportederror the specified connection would create a cycle (in which the audio loops back through the same nodes repeatedly) and there are no delaynodes in the cycle to prevent the resulting waveform from getting stuck constructing the same audio frame indefinitely.

Service Worker API - Web APIs
download, install and activate at this point, your service worker will observe the following lifecycle: download install activate the service worker is immediately downloaded when a user first accesses a service worker–controlled site/page.
... interfaces cache represents the storage for request / response object pairs that are cached as part of the serviceworker life cycle.
... extendableevent extends the lifetime of the install and activate events dispatched on the serviceworkerglobalscope, as part of the service worker lifecycle.

symbols() - CSS: Cascading Style Sheets
[ <string> | <image> ]+ ); <symbols-type> can be one of the following: cyclic: the system cycles through the given values in the order of their definition, and returns to the start when it reaches the end.
... symbolic: the system cycles through the values, printing them an additional time at each cycle (one time for the first cycle, two times for the second, etc.).
... fixed: the system cycles through the given values once, then falls back to arabic numerals.

Intl.DateTimeFormat() constructor - JavaScript
hc hour cycle.
...this option overrides the hc language tag and/or the hourcycle option in case both are present.
... hourcycle the hour cycle to use.

JavaScript Daemons Management - Archive of obsolete content
"start" : "syncstart"](true); }; daemon.prototype.move = function (bsync, ncycles, bdirection) { /* warning: this method optionally requires the daemon.prototype.syncstart() method */ if (arguments.length > 1 && !isnan(ncycles)) { this.reversals = number(ncycles); } this[bsync ?
....rate) + this.index; this.pause(); this.start(); } return this.length; }; manual the constructor syntax var mydaemon = new daemon(thisobject, callback[, rate[, length[, init[, onstart]]]]); description constructs a javascript object containing all information needed by an animation (like the this object, the callback function, the length, the frame rate, the number of cycles, and the init and onstart functions).

Creating custom Firefox extensions with the Mozilla build system - Archive of obsolete content
this will let you run both versions of firefox simultaneously, saving you oodles of time over the course of the build/test cycle.
... the most convenient approach from the perspective of the development cycle is to create a mozilla-style makefile for the library.

Index - Archive of obsolete content
34 sdk api lifecycle no summary!
... 830 cycler xul attributes, xul reference no summary!

MMgc - Archive of obsolete content
so far something interesting means an incremental mark cycle, a sweep or a drc reap.
...the result will be at the end of the mark cycle fewer things need to be marked.

Textbox (XPFE autocomplete) - Archive of obsolete content
tabscrolling obsolete since gecko 1.9.1 type: boolean if true, the user may cycle through the results list by pressing the tab key.
... tabscrolling new in thunderbird 3requires seamonkey 2.0 type: boolean if true, the user may cycle through the results list by pressing the tab key.

Introduction to Public-Key Cryptography - Archive of obsolete content
there are two major stages in the lifecycle of a certificate: the point when it is issued (issuance and enrollment) and the period when the certificates are no longer valid (renewal or revocation).
... there are also ways to manage the certificate during its lifecycle.

Houdini - MDN Web Docs Glossary: Definitions of Web-related terms
houdini code doesn't wait for that first rendering cycle to be complete.
... rather, it is included in that first cycle, creating renderable, understandable styles.

Index - MDN Web Docs Glossary: Definitions of Web-related terms
340 prototype apps, composing, glossary a prototype is a model that displays the appearance and behavior of an application or product early in the development lifecycle.
... 413 server timing glossary, reference, server timing, web performance the server timing specification enables the server to communicate performance metrics from the request-response cycle to the user agent, and utilizes a javascript interface to allow applications to collect, process, and act on these metrics to optimize application delivery.

Mobile accessibility - Learn web development
swipe left and right to cycle between the different options.
...you can go back and forth to cycle through the options.

WAI-ARIA basics - Learn web development
states differ from properties in that properties don't change throughout the lifecycle of an app, whereas states can change, generally programmatically via javascript.
... if you go to voiceover's landmarks menu (accessed using voiceover key + u and then using the cursor keys to cycle through the menu choices), you'll see that most of the elements are nicely listed so they can be accessed quickly.

Backgrounds and borders - Learn web development
the answer is that the smaller numbers of values will cycle — in the above example there are four background images but only two background-position values.
... the first two position values will be applied to the first two images, then they will cycle back around again — image3 will be given the first position value, and image4 will be given the second position value.

Client-side storage - Learn web development
we'll start off by creating references to all the html features we need to manipulate in this example — we'll create them all as constants, as these references do not need to change in the lifecycle of the app.
... add a bunch of event handlers to the request and the transaction to run code at critical points in the lifecycle.

Drawing graphics - Learn web development
code for the loop that keeps everything moving looks like this: function loop() { ctx.fillstyle = 'rgba(0, 0, 0, 0.25)'; ctx.fillrect(0, 0, width, height); for(let i = 0; i < balls.length; i++) { balls[i].draw(); balls[i].update(); balls[i].collisiondetect(); } requestanimationframe(loop); } loop(); we run the loop() function once at the bottom of the code to start the cycle, drawing the first animation frame; the loop() function then takes charge of calling requestanimationframe(loop) to run the next frame of the animation, again and again.
... let sprite = 0; let posx = 0; let's explain the spritesheet image (which we have respectfully borrowed from mike thomas' create a sprite sheet walk cycle using css animation).

Ember resources and troubleshooting - Learn web development
a route only has 3 lifecycle hooks, all of which are optional: beforemodel — gate access to the route.
...and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Routing in Ember - Learn web development
model is a data loading lifecycle hook.
...and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

React resources - Learn web development
state and lifecycle in the react docs intro to react in the react docs read about javascript classes at mdn testing create-react-app provides some tools for testing your application out of the box — you may have deleted the relevant files earlier in the tutorial.
...and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Deploying our app - Learn web development
post development there's potentially a large range of problems to be solved in this section of the project's lifecycle.
... deploying to hosting tends to be at the tail-end of the project life cycle, but with services such as netlify bringing down the cost of deployments (both in financial terms and also the time required to actually deploy) it's possible to deploy during development to either share work in progress or to have a pre-release for some other purpose.

HTTP logging
this is accomplished by splitting the log into up to 4 separate files (their filenames have a numbered extension, .0, .1, .2, .3) the logging back end cycles the files it writes to, while ensuring that the sum of these files’ sizes will never go over the specified limit.
... we don’t move the files, we only cycle.

Using the Browser API
then, we disable the "previous" and "next" search item buttons so that they don't run anything unless there are search items to cycle between.
... searchform.addeventlistener('submit',function(e) { e.preventdefault(); browser.findall(searchbar.value, 'case-sensitive'); searchactive = true; prev.disabled = false; next.disabled = false; searchbar.blur(); }); with this all done, you'll see your search results are highlighted; you can cycle through these using the htmliframeelement.findnext() method (specify forward and backward to go in either direction through the results), which is what our next two event listeners do: prev.addeventlistener('touchend',function() { browser.findnext("backward"); }); next.addeventlistener('touchend',function() { browser.findnext("forward"); }); the last event listener in this section controls...

HTMLIFrameElement.findNext()
parameters direction a string indicating the direction in which you want to cycle through the available search results.
... examples the following functions are taken from our browser api demo, and cycle through the available search results.

Extending a Protocol
it's also "refcounted", meaning it we can use refptr<> for instances that can be cycle collected.
...scroll to the end and add private member: refptr<echochild> mechochild; } // namespace dom } // namespace mozilla navigator.cpp - getechochild() now, add the following includes at the top of the file: #include "mozilla/dom/echochild.h" #include "mozilla/dom/windowglobalchild.h" to the "ns_impl_cycle_collection_unlink_begin(navigator)" we can now tell gecko that mechochild can participate, so let's add: ns_impl_cycle_collection_unlink(mechochild) now, the getechochild() private method will do the intial setup for us.

Components.utils.schedulePreciseGC
this method lets scripts schedule a garbage collection cycle.
... the garbage collection cycle will occur sometime in the future, when no javascript code is executing.

imgILoader
libpr0n does not keep a strong ref to the observer; this prevents reference cycles.
...libpr0n does not keep a strong ref to the observer; this prevents reference cycles.

nsIMsgCustomColumnHandler
you must implement: nsitreeview.iseditable() nsitreeview.getcellproperties() nsitreeview.getimagesrc() nsitreeview.getcelltext() nsitreeview.cyclecell() nsimsgcustomcolumnhandler.getsortstringforrow() nsimsgcustomcolumnhandler.getsortlongforrow() nsimsgcustomcolumnhandler.isstring() and optionally: nsitreeview.getrowproperties() from c++ you must implement all of nsitreeview and nsimsgcustomcolumnhandler.
... example implementation an example javascript implementation that does nothing: var columnhandler = { iseditable: function(arow, acol) {return false;}, cyclecell: function(arow, acol) { }, getcelltext: function(arow, acol) { }, getsortstringforrow: function(ahdr) { return ""; }, isstring: function() {return true;}, getcellproperties: function(arow, acol, aprops) { }, getrowproperties: function(arow, aprops) { }, getimagesrc: function(arow, acol) {return null;}, getsortlongforrow: function(ahdr) {return 0;} } to attach it use the nsimsgdbview.addcolumnhandler() method (recall gdbview is the global nsimsgdbview in thunderbird): gdbview.addcolumnhandler("newcolumn", columnhandler); after which it can be retrieved using the nsimsgdbview.getcolu...

nsITreeColumn
cycler boolean if true, then the column is a cycler column.
... if the cycler attribute is not set, the column cells are regular text cells.

nsIXPConnect
rown missing exception missing description movewrappers() void movewrappers( in jscontextptr ajscontext, in jsobjectptr aoldscope, in jsobjectptr anewscope ); parameters ajscontext missing description aoldscope missing description anewscope missing description exceptions thrown missing exception missing description notejscontext() note: ajscontext as a child to the cycle collector.
... acb the cycle collection traversal callback.

XPCOM ownership guidelines
anytime there is a cycle of ownership, there is a situation that isn't automatically handled by destructors.
... special code must be provided and called to break the cycle before the participants can be individually released.

All keyboard shortcuts - Firefox Developer Tools
command windows macos linux cycle through tools left to right ctrl + ] cmd + ] ctrl + ] cycle through tools right to left ctrl + [ cmd + [ ctrl + [ toggle between active tool and settings.
...as been entered) esc esc esc step forward through properties and values tab tab tab step backward through properties and values shift + tab shift + tab shift + tab start editing property or value (rules view only, when a property or value is selected, but not already being edited) enter or space return or space enter or space cycle up and down through auto-complete suggestions (rules view only, when a property or value is being edited) up arrow , down arrow up arrow , down arrow up arrow , down arrow choose current auto-complete suggestion (rules view only, when a property or value is being edited) enter or tab return or tab enter or tab increment selected value by 1 up arrow up arr...

Element.shadowRoot - Web APIs
examples the following snippets are taken from our life-cycle-callbacks example (see it live also), which creates an element that displays a square of a size and color specified in the element's attributes.
... inside the <custom-square> element's class definition we include some life cycle callbacks that make a call to an external function, updatestyle(), which actually applies the size and color to the element.

HTMLCanvasElement.getContext() - Web APIs
desynchronized: boolean that hints the user agent to reduce the latency by desynchronizing the canvas paint cycle from the event loop (gecko only) willreadfrequently: boolean that indicates whether or not a lot of read-back operations are planned.
... desynchronized: boolean that hints the user agent to reduce the latency by desynchronizing the canvas paint cycle from the event loop antialias: boolean that indicates whether or not to perform anti-aliasing.

ServiceWorker - Web APIs
a serviceworker object is available in the serviceworkerregistration.active property, and the serviceworkercontainer.controller property — this is a service worker that has been activated and is controlling the page (the service worker has been successfully registered, and the controlled page has been reloaded.) the serviceworker interface is dispatched a set of lifecycle events — install and activate — and functional events including fetch.
... a serviceworker object has an associated serviceworker.state, related to its lifecycle.

ShadowRoot - Web APIs
examples the following snippets are taken from our life-cycle-callbacks example (see it live also), which creates an element that displays a square of a size and color specified in the element's attributes.
... inside the <custom-square> element's class definition we include some life cycle callbacks that make a call to an external function, updatestyle(), which actually applies the size and color to the element.

Writing a WebSocket server in C# - Web APIs
tcpclient client = server.accepttcpclient(); console.writeline("a client connected."); networkstream stream = client.getstream(); //enter to an infinite cycle to be able to handle every change in stream while (true) { while (!stream.dataavailable); byte[] bytes = new byte[client.available]; stream.read(bytes, 0, bytes.length); } handshaking when a client connects to a server, it sends a get request to upgrade the connection to a websocket from a simple http request.
... int port = 80; var server = new tcplistener(ipaddress.parse(ip), port); server.start(); console.writeline("server has started on {0}:{1}, waiting for a connection...", ip, port); tcpclient client = server.accepttcpclient(); console.writeline("a client connected."); networkstream stream = client.getstream(); // enter to an infinite cycle to be able to handle every change in stream while (true) { while (!stream.dataavailable); while (client.available < 3); // match against "get" byte[] bytes = new byte[client.available]; stream.read(bytes, 0, client.available); string s = encoding.utf8.getstring(bytes); if (regex.ismatch(s, "^get", regexoptions.ignor...

Rendering and the WebXR frame animation callback - Web APIs
this is due to early displays using the ac electrical grid's current flow waveform, which cycles 60 times per second in the united states (50 in europe), for timing purposes.
...tearing occurs when the the display hardware starts the next refresh cycle while the previous frame is still being drawn to the screen.

Window.open() - Web APIs
using a single target attribute value and reusing it in links is much more user resources friendly as it only creates one single secondary window, which is recycled.
... on the other hand, using "_blank" as the target attribute value will create several new and unnamed windows on the user's desktop that cannot be recycled, reused.

Using CSS animations - CSS: Cascading Style Sheets
animation-duration configures the length of time that an animation should take to complete one cycle.
...in such cases where there are not enough values to give a separate value to each animation, the values cycle from start to finish.

Using CSS gradients - CSS: Cascading Style Sheets
the colors get cycled over again as the gradient repeats.
...the colors get cycled over and over as the gradient repeats.

animation-duration - CSS: Cascading Style Sheets
the animation-duration css property sets the length of time that an animation takes to complete one cycle.
... syntax /* single animation */ animation-duration: 6s; animation-duration: 120ms; /* multiple animations */ animation-duration: 1.64s, 15.22s; animation-duration: 10s, 35s, 230ms; values <time> the time that an animation takes to complete one cycle.

Compression in HTTP - HTTP
compression algorithms used for files can be grouped into two broad categories: loss-less compression, where the compression-uncompression cycle doesn't alter the data that is recovered.
... lossy compression, where the cycle alters the original data in a (hopefully) imperceptible way for the user.

CSS Houdini
houdini code doesn't wait for that first rendering cycle to be complete.
... rather, it is included in that first cycle — creating renderable, understandable styles.

Intl.ListFormat - JavaScript
const list = ['motorcycle', 'bus', 'car']; console.log(new intl.listformat('en-gb', { style: 'long', type: 'conjunction' }).format(list)); // > motorcycle, bus and car console.log(new intl.listformat('en-gb', { style: 'short', type: 'disjunction' }).format(list)); // > motorcycle, bus or car console.log(new intl.listformat('en-gb', { style: 'narrow', type: 'unit' }).format(list)); // > motorcycle bus car using for...
...mattoparts the following example shows how to create a list formatter returning formatted parts const list = ['motorcycle', 'bus', 'car']; console.log(new intl.listformat('en-gb', { style: 'long', type: 'conjunction' }).formattoparts(list)); // [ { "type": "element", "value": "motorcycle" }, // { "type": "literal", "value": ", " }, // { "type": "element", "value": "bus" }, // { "type": "literal", "value": ", and " }, // { "type": "element", "value": "car" } ]; specifications specification intl.listformatthe definition of 'listformat' in that specification.

Intl.Locale.prototype.maximize() - JavaScript
examples of these subtags include locale.hourcycle, locale.calendar, and locale.numeric.
... examples using maximize let mylocale = new intl.locale("fr", {hourcycle: "h24", calendar: "gregory"}); console.log(mylocale.basename); // prints "fr" console.log(mylocale.tostring()); // prints "fr-u-ca-gregory-hc-h24" let mylocmaximized = mylocale.maximize(); // prints "fr-latn-fr".

Intl.Locale.prototype.minimize() - JavaScript
examples of these subtags include locale.hourcycle, locale.calendar, and locale.numeric.
... examples using minimize let mylocale = new intl.locale("fr-latn-fr", {hourcycle: "h24", calendar: "gregory"}); console.log(mylocale.basename); // prints "fr-latn-fr" console.log(mylocale.tostring()); // prints "fr-latn-fr-u-ca-gregory-hc-h24" let mylocminimized = mylocale.minimize(); // prints "fr", since french is only written in the latin script // and is most likely to be spoken in france.

Intl.Locale - JavaScript
intl.locale.prototype.hourcycle returns the time keeping format convention used by the locale.
...for example, set the hourcycle property of the configuration object to your desired hour cycle type, and then pass it into the constructor: let us12hour = new intl.locale("en-us", {hourcycle: "h12"}); console.log(us12hour.hourcycle); // prints "h12" specifications specification ecmascript internationalization api (ecma-402) ...

for - JavaScript
var i = 0; for (;;) { if (i > 3) break; console.log(i); i++; } using for without a statement the following for cycle calculates the offset position of a node in the final-expression section, and therefore it does not require the use of a statement section, a semicolon is used instead.
...indeed, without the semicolon the line that follows the cycle declaration will be considered a statement.

JavaScript
since then, ecmascript standards are on yearly release cycles.
... memory management memory life cycle and garbage collection in javascript.

Web Components
tutorials using custom elements a guide showing how to use the features of custom elements to create simple web components, as well as looking into lifecycle callbacks and some other more advanced features.
... life cycle callbacks special callback functions defined inside the custom element's class definition, which affect its behavior: connectedcallback: invoked when the custom element is first connected to the document's dom.

Guides - Archive of obsolete content
sdk api lifecycle definition of the lifecycle for the sdk's apis, including the stability ratings for apis.

ui/toolbar - Archive of obsolete content
hidden state persists even over create/destroy cycles: if a toolbar is created, then hidden, then destroyed, and another toolbar with the same title is then created, the new toolbar will be in the hidden state.

Miscellaneous - Archive of obsolete content
// this excludes textareas for simplicity, but onpageload() can easily be // modified to cycle through textareas as well.

Performance best practices in extensions - Archive of obsolete content
general performance tips avoid creating memory leaks memory leaks require the garbage collector and the cycle collector to work harder, which can significantly degrade performance.

Index of archived content - Archive of obsolete content
ributor's guide classes and inheritance content processes getting started modules private properties firefox compatibility module structure of the sdk porting the library detector program id sdk api lifecycle sdk and xul comparison testing the add-on sdk two types of scripts working with events xul migration guide high-level apis addon-page base64 clipboard context-menu hotkeys indexe...

Prism - Archive of obsolete content
benefits separate process: web apps can hog memory or processor cycles or even bring down the whole browser in extreme cases.

Table Layout Regression Tests - Archive of obsolete content
change the source if necessary until the regression tests indicate that your patch does not fork the block and table layout submit your patch and lists the remaining differences in the bug be prepared to cycle.

Video presentations - Archive of obsolete content
(as quicktime; 127 mb, 50 mb, and 68 mb) the life cycle of a bug (part 1, part 2) mike connor describes how a bug goes from bug report to patch to implemented fix.

tabscrolling - Archive of obsolete content
« xul reference home tabscrolling new in thunderbird 3requires seamonkey 2.0 type: boolean if true, the user may cycle through the results list by pressing the tab key.

textbox.tabScrolling - Archive of obsolete content
« xul reference home tabscrolling obsolete since gecko 1.9.1 type: boolean if true, the user may cycle through the results list by pressing the tab key.

Attribute (XUL) - Archive of obsolete content
ra1 buttonlabelextra2 buttonlabelhelp buttonorient buttonpack buttons checked checkstate clicktoscroll class closebutton closemenu coalesceduplicatearcs collapse collapsed color cols command commandupdater completedefaultindex container containment contentcontextmenu contenttooltip context contextmenu control crop curpos current currentset customindex customizable cycler datasources decimalplaces default defaultbutton defaultset description dir disableautocomplete disableautoselect disableclose disabled disablehistory disablekeynavigation disablesecurity dlgtype dragging editable editortype element empty emptytext deprecated since gecko 2 enablecolumndrag enablehistory equalsize eventnode events expr firstdayofweek firstpage first-...

Index - Archive of obsolete content
83 cycler xul attributes, xul reference no summary!

PopupKeys - Archive of obsolete content
in a menubar, cursor left and right will cycle between top level menus.

Sorting and filtering a custom tree view - Archive of obsolete content
ner = function(row){ return false; }; this.isseparator = function(row){ return false; }; this.issorted = function(){ return false; }; this.getlevel = function(row){ return 0; }; this.getimagesrc = function(row,col){ return null; }; this.getrowproperties = function(row,props){}; this.getcellproperties = function(row,col,props){}; this.getcolumnproperties = function(colid,col,props){}; this.cycleheader = function(col, elem) {}; } function sort(column) { var columnname; var order = tree.getattribute("sortdirection") == "ascending" ?

textbox (Toolkit autocomplete) - Archive of obsolete content
tabscrolling new in thunderbird 3requires seamonkey 2.0 type: boolean if true, the user may cycle through the results list by pressing the tab key.

Tree Widget Changes - Archive of obsolete content
the nsitreeview.cycleheader() method has been changed, cycleheader(colid, element) is now just cycleheader(column), since the code can get the element from the column object.

Numeric Controls - Archive of obsolete content
in addition, arrow buttons appear beside the textbox to allow the user to cycle through the values.

Tree View Details - Archive of obsolete content
sert = this.childdata[label]; for (var i = 0; i < toinsert.length; i++) { this.visibledata.splice(idx + i + 1, 0, [toinsert[i], false]); } this.treebox.rowcountchanged(idx + 1, toinsert.length); } this.treebox.invalidaterow(idx); }, getimagesrc: function(idx, column) {}, getprogressmode : function(idx,column) {}, getcellvalue: function(idx, column) {}, cycleheader: function(col, elem) {}, selectionchanged: function() {}, cyclecell: function(idx, column) {}, performaction: function(action) {}, performactiononcell: function(action, index, column) {}, getrowproperties: function(idx, prop) {}, getcellproperties: function(idx, column, prop) {}, getcolumnproperties: function(column, element, prop) {}, }; function init() { document.geteleme...

XBL Example - Archive of obsolete content
navigation buttons along the bottom will allow the user to cycle through the objects while a text widget between the buttons will display the current page.

XUL accessibility guidelines - Archive of obsolete content
flickering or flashing is not only just annoying to everyone, but at a rate more than 3 cycles per second it can cause a seizure in users with photosensitive epilepsy.

Creating XULRunner Apps with the Mozilla Build System - Archive of obsolete content
you can add it at the end if you want to make an installer every time you build the app, but this will add significant time to each build cycle.

XULRunner Hall of Fame - Archive of obsolete content
version updates match the rapid release cycle.

What XULRunner Provides - Archive of obsolete content
ither already implemented or planned: gecko features xpcom networking gecko rendering engine dom editing and transaction support (no ui) cryptography xbl (xbl2 planned) xul svg xslt xml extras (xmlhttprequest, domparser, etc.) web services (soap) auto-update support (not yet complete) type ahead find toolbar history implementation (the places implementation in the 1.9 cycle) accessibility support ipc services for communication between gecko-based apps (not yet complete) storage/sqlite interfaces user interface features the following user interface is supplied by xulrunner, and may be overridden by embedders under certain circumstances: apis and user interface for installing, uninstalling, and upgrading xul applications.

2006-10-27 - Archive of obsolete content
traffic status of xpcom cycle collector graydon hoare provides the xpcom patch which experiments with implementing a general-purpose garbage-cycle collector for xpcom.

2006-11-17 - Archive of obsolete content
recycle array objects a user trying to overcome the need of using huge number of arrays (as vectors) asks if its possible to reuse unreferenced array objects instead of create new ones in spidermonkey.

External resources for plugin creation - Archive of obsolete content
npapi articles, information, and tutorials npapi has been around a very long time, and there have been many attempts to distill down useful information on creating them: colonelpanic.net building a firefox plugin - part one: discusses the difference between npapi and npruntime and summarizes the basic apis needed to create a plugin building a firefox plugin - part two: discusses the basic lifecycle of a npapi plugin building a firefox plugin - part three: discusses npobjects and how to use them memory management in npapi: discusses how memory is managed in a npapi plugin browser plugins vs extensions (add-ons) -- the difference: discusses the oft-misunderstood difference between a plugin and an extension wikipedia npapi: history and general information about npapi plugins and extensions: ...

NSPR Release Engineering Guide - Archive of obsolete content
nspr generally follows the iplanet product lifecycle.

Scratchpad - Archive of obsolete content
↑ and ↓ cycle through the suggestions and enter or tab select the highlighted choice.

Server-Side JavaScript - Archive of obsolete content
today with computing cycles having increased more than 10-fold and mozilla's work on rhino (javascript interpreter in java) and spidermonkey (javascript interpreter in c) and javascript itself, we have very solid foundations for javascript to be extraordinarily useful and applicable on the server-side again -- with performance in the same range as popular server-side environments like php and ruby on rails.

Obsolete: XPCOM-based scripting for NPAPI plugins - Archive of obsolete content
npp_getvalue implementation and possible scenario of scriptable object life cycle #include "nsitestplugin.h" nperror npp_new(npmimetype plugintype, npp instance, uint16 mode, int16 argc, char* argn[], char* argv[], npsaveddata* saved) { if(instance == null) return nperr_invalid_instance_error; // just prime instance->pdata with null for the purpose of this example // it will be assigned to the scriptable interface later to keep its // as...

2D collision detection - Game development
ng sat is out of scope for this page so see the recommended tutorials below: separating axis theorem (sat) explanation collision detection and response collision detection using the separating axis theorem sat (separating axis theorem) separating axis theorem collision performance while some of these algorithms for collision detection are simple enough to calculate, it can be a waste of cycles to test *every* entity with every other entity.

Building up a basic demo with the PlayCanvas engine - Game development
add the following, again into the callback: cylinder.setlocalscale(1, math.abs(math.sin(timer)), 1); here we are using math.sin to scale the cylinder in a cycle, bigger and smaller again.

Desktop gamepad controls - Game development
hold')) { if(!this.screengamepadhelp.visible) { this.screengamepadhelp.visible = true; } } else { if(this.screengamepadhelp.visible) { this.screengamepadhelp.visible = false; } } if the b button is pressed, the game is paused: if(gamepadapi.buttonpressed('b')) { this.managepause(); } pause and game over states we already learned how to control the whole lifecycle of the game: pausing the gameplay, restarting it, or getting back to the main menu.

Prototype - MDN Web Docs Glossary: Definitions of Web-related terms
a prototype is a model that displays the appearance and behavior of an application or product early in the development lifecycle.

Server Timing - MDN Web Docs Glossary: Definitions of Web-related terms
the server timing specification enables the server to communicate performance metrics from the request-response cycle to the user agent, and utilizes a javascript interface to allow applications to collect, process, and act on these metrics to optimize application delivery.

HTML: A good basis for accessibility - Learn web development
other form elements have different controls, for example, the <select> element can have its options displayed and cycled between using the up and down arrow keys.

HTML: A good basis for accessibility - Learn web development
other form elements have different controls, for example, the <select> element can have its options displayed and cycled between using the up and down arrow keys.

What HTML features promote accessibility? - Learn web development
you might want to allow someone to jump over a plethora of navigation links, for example, so they can just read a page’s main content rather than cycle through all of the links.

Index - Learn web development
272 advanced svelte: reactivity, lifecycle, accessibility accessibility, beginner, components, frameworks, javascript, learn, lifecycle, svelte, client-side, reactivity in this article we have finished adding all the required functionality to our app, plus we've taken care of a number of accessibility and usability issues.

Cooperative asynchronous JavaScript: Timeouts and intervals - Learn web development
this example therefore throttles the rate at which the sprite cycles its frames using the following code: if (posx % 13 === 0) { if (sprite === 5) { sprite = 0; } else { sprite++; } } so the code only cycles the sprite once every 13 animation frames.

Client-Server Overview - Learn web development
anatomy of a dynamic request this section provides a step-by-step overview of the "dynamic" http request and response cycle, building on what we looked at in the last article with much more detail.

Ember Interactivity: Footer functionality, conditional rendering - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Getting started with Ember - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Ember interactivity: Events, classes and state - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Ember app structure and componentization - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Introduction to client-side frameworks - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Accessibility in React - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Componentizing our React app - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Getting started with React - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

React interactivity: Events and state - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

React interactivity: Editing, filtering, conditional rendering - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Beginning our React todo list - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Starting our Svelte Todo list app - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

TypeScript support in Svelte - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Componentizing our Svelte app - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Deployment and next steps - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Getting started with Svelte - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Dynamic behavior in Svelte: working with variables and props - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Using Vue computed properties - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Vue conditional rendering: editing existing todos - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Creating our first Vue component - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Getting started with Vue - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Adding a new todo form: Vue events, methods, and models - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Rendering a list of Vue components - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Vue resources - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Styling Vue components with CSS - Learn web development
and models styling vue components with css using vue computed properties vue conditional rendering: editing existing todos focus management with vue refs vue resources svelte getting started with svelte starting our svelte todo list app dynamic behavior in svelte: working with variables and props componentizing our svelte app advanced svelte: reactivity, lifecycle, accessibility working with svelte stores typescript support in svelte deployment and next steps ...

Understanding client-side JavaScript frameworks - Learn web development
advanced svelte: reactivity, lifecycle, accessibility in this article we will add the app's final features and further componentize our app.

Handling common accessibility problems - Learn web development
you can then press enter/return to follow a focused link or press a button (we've included some javascript to make the buttons alert a message), or start typing to enter text in a text input (other form elements have different controls, for example the <select> element can have its options displayed and cycled between using the up and down arrow keys).

Handling common JavaScript problems - Learn web development
but even then, most bugs get fixed pretty quickly in browser vendor rapid release cycles.

Command line crash course - Learn web development
note that this delete is permanent and can’t be undone via the recycle bin that you might have on your desktop user interface.

Understanding client-side web development tools - Learn web development
client-side tooling overview in this article we provide an overview of modern web tooling, what kinds of tools are available and where you’ll meet them in the lifecycle of web app development, and how to find help with individual tools.

Mozilla Plugin Accessibility
the plugin will be responsible for bubbling up shift+tab and tab when the user has reached the end of the tab cycle within the plugin.

Accessible Toolkit Checklist
tab order must wrap, not have invisible items in tab order dynamically added items must not corrupt the tab cycle or make it disorderly tab cycle must be identical backwards and forwards the f6 and shift+f6 key combinations should cycle through panes in a window making focus visible on any widget, and focus must always be visible shift+f10 or context menu key should work like right click on focused item, and context menu should show just under and to the right of the current focus.

Application cache implementation overview
when concurrency limit is reached, the processnexturi self-invocation cycle is stopped.

Makefiles - Best practices and suggestions
incorrect dependencies will contribute to wasted cycles and can contribute to circular dependencies.

Experimental features in Firefox
nightly 75 yes developer edition 75 no beta 75 no release 75 no preference name dom.forms.inputmode <link rel="preload"> the <link> element's rel attribute is intended to help provide performance gains by letting you download resources earlier in the page lifecycle, ensuring that they're available earlier and are less likely to block page rendering.

Security best practices for Firefox front-end engineers
the last flag ensures that developers will identify and avoid the problems early on in the development cycle and before shipping the code.

HTTP Cache
other parallel openers of the same cache entry are blocked (wait) for invocation of their oncacheentryavailable until one of the following occurs: the writer simply throws the entry away: other waiting opener in line gets the entry again as "new", the cycle repeats.

Localization content best practices
late-l10n: it's used by release-drivers to identify bugs, involving new strings, that will land late in the cycle, typically after soft string freeze in firefox os.

Writing localizable code
any changed or new use of existing localized strings; anything that triggers a qa cycle on our 40+ localizations is l10n-impact.

NSPR release process
the build+test cycles of the nss tinderboxes are very long, so you usually need to wait half a day for them to cycle through.

NSS 3.14.2 release notes
if so, nss uses the optimized code path, reducing the cpu cycles per byte to 1/20 of what was required before the patch (https://bugzilla.mozilla.org/show_bug.cgi?id=805604 and https://crypto.stanford.edu/realworldcrypto/slides/gueron.pdf).

NSS 3.55 release notes
bug 1649190 - run cipher, sdr, and ocsp tests under standard test cycle in ci.

GC Rooting Guide
js::handle<t> exists because creating and destroying a js::rooted<t> is not free (though it only costs a few cycles).

Exact Stack Rooting
modern c++ compilers are not smart enough to do licm on js::rootedt, so forward declaring a single js::rootedt above the loop and re-using it on every iteration can save some cycles.

Property cache
occasionally, during garbage collection, all shape ids are regenerated (in order to recycle unused shape ids so that we don't run out; see calls to js_regenerateshapeforgc.

Tracing JIT
a fragmento is a resource-management object that allocates and stores a set of fragments and pages, and manages their lifecycle.

JS::Add*Root
the garbage collector aggressively collects and recycles memory that it deems unreachable, so roots are often necessary to protect data from being prematurely collected.

JS::CompileOptions
thus, instances of this type can't be owned, directly or indirectly, by a javascript object: if any value that this roots ever comes to refer to the object that owns this, then the whole cycle, and anything else it entrains, will never be freed.

JSExtendedClass.wrappedObject
(the result may be "object", "function", or "xml".) when assigning to __proto__ or __parent__ from script, the javascript engine checks to see if the assignment would produce a cycle.

JSObjectOps.setProto
description these hooks must check for cycles without deadlocking, and otherwise take special steps.

JS_Add*Root
the garbage collector aggressively collects and recycles memory that it deems unreachable, so roots are often necessary to protect data from being prematurely collected.

JS_DumpHeap
jstrace_object = 0x00, jstrace_string = 0x01, jstrace_symbol = 0x02, jstrace_script = 0x03, // shape details are exposed through js_traceshapecyclecollectorchildren.

JS_MapGCRoots
this function acquires and releases rt's gc lock around the mapping of the roots table, so the map function should run to completion in as few cycles as possible.

JS_MaybeGC
implementation note: spidermonkey 1.8 and earlier determine whether garbage collection is appropriate by analyzing statistics about the gc heap and memory usage since the last garbage collection cycle.

JS_NewCompartmentAndGlobalObject
the caller must ensure that the jsclass remains alive throughout the lifetime of the new object, including the garbage collection cycle that finally frees it.

JS_NewGlobalObject
the caller must ensure that the jsclass remains alive throughout the lifetime of the new object, including the garbage collection cycle that finally frees it.

JS_NewObject
if clasp is non-null, the caller must ensure that the jsclass remains alive throughout the lifetime of the new object, including the garbage collection cycle that finally frees it.

JS_TracerInit
in this case the callback must be prepared to deal with cycles in the traversal graph.

Components object
utils.forcegc forces a garbage collection cycle.

IAccessible2
each time an object's life cycle ended, its number would be saved into a reuse pool.

nsIAuthModule
the buffer at aouttoken must be recycled with a call to nsimemory.free().

nsIMarkupDocumentViewer
note: this attribute was added late in the gecko 2.0 development cycle and was implemented by the nsimarkupdocumentviewer_mozilla_2_0_branch interface; it was merged into this interface in gecko 7.0.

nsINavHistoryResult
when a result goes out of scope it will continue to observe changes till it is cycle collected.

Component; nsIPrefBranch
these cycles generally occur because an object both registers itself as an observer (causing the branch to hold a reference to the observer) and holds a reference to the branch object for the purpose of getting/setting preference values.

nsIPrefBranch2
these cycles generally occur because an object both registers itself as an observer (causing the branch to hold a reference to the observer) and holds a reference to the branch object for the purpose of getting/setting preference values.

nsISelectionController
this is still true when the caret is enabled, visible, but in its "off" blink cycle.

XPCOM Interface Reference
e2nsicontentsecuritypolicynsicontentsniffernsicontentviewnsicontentviewmanagernsicontentviewernsicontrollernsicontrollersnsiconverterinputstreamnsiconverteroutputstreamnsicookiensicookie2nsicookieacceptdialognsicookieconsentnsicookiemanagernsicookiemanager2nsicookiepermissionnsicookiepromptservicensicookieservicensicookiestoragensicrashreporternsicryptohmacnsicryptohashnsicurrentcharsetlistenernsicyclecollectorlistenernsidbchangelistenernsidbfolderinfonsidnslistenernsidnsrecordnsidnsrequestnsidnsservicensidomcanvasrenderingcontext2dnsidomchromewindownsidomclientrectnsidomdesktopnotificationnsidomdesktopnotificationcenternsidomelementnsidomeventnsidomeventgroupnsidomeventlistenernsidomeventtargetnsidomfilensidomfileerrornsidomfileexceptionnsidomfilelistnsidomfilereadernsidomfontfacensidomfontfac...

Getting Started Guide
in fact, if two objects somehow end up owning each other (even transitively) it becomes difficult for either of those object to be reclaimed without adding some `out-of-band' mechanism for breaking the ownership cycle.

Weak reference
if, for instance, this owning reference is part of a cycle of owning references (e.g., if the referenced object also holds a owning reference back to you), then none of the objects in the cycle can be reclaimed without taking special measures.

XPCOM
for more information on the workings of xpcom look elsewhere.how to pass an xpcom object to a new windowif you want to be able to call functions within an xpcom object from a xul window's code, you can do so if you pass the xpcom object as one of the arguments to the window creation method.interfacing with the xpcom cycle collectorthis is a quick overview of the cycle collector introduced into xpcom for firefox 3, including a description of the steps involved in modifying an existing c++ class to participate in xpcom cycle collection.

Cached compose window FAQ
user_pref("mail.compose.max_recycled_windows", 1); where can i read more about it?

Plug-in Basics - Plugins
how plug-ins work the life cycle of a plug-in, unlike that of an application, is completely controlled by the web page that calls it.

Debugging service workers - Firefox Developer Tools
when the service worker is stopped, a start button is provided to start it running, allowing you to trigger the service worker lifecycle.

Debugger - Firefox Developer Tools
if adding the designated global’s compartment would create a cycle of debugger and debuggee compartments, this method throws an error.

Examine and edit CSS - Firefox Developer Tools
the color scheme simulator has four states, which you can cycle through by clicking the button repeatedly: icon value description null the prefers-color-scheme media feature is not defined.

Page inspector keyboard shortcuts - Firefox Developer Tools
as been entered) esc esc esc step forward through properties and values tab tab tab step backward through properties and values shift + tab shift + tab shift + tab start editing property or value (rules view only, when a property or value is selected, but not already being edited) enter or space return or space enter or space cycle up and down through auto-complete suggestions (rules view only, when a property or value is being edited) up arrow , down arrow up arrow , down arrow up arrow , down arrow choose current auto-complete suggestion (rules view only, when a property or value is being edited) enter or tab return or tab enter or tab increment selected value by 1 up arrow up arr...

Allocations - Firefox Developer Tools
if you click this link, the devtools switches to the allocations view, and selects the region of time from the end of the last gc cycle to the start of the one you clicked on.

Toolbox - Firefox Developer Tools
command windows macos linux cycle through tools left to right ctrl + ] cmd + ] ctrl + ] cycle through tools right to left ctrl + [ cmd + [ ctrl + [ toggle between active tool and settings.

The JavaScript input interpreter - Firefox Developer Tools
repeatedly typing f9 on windows and linux ( ctrl+r on mac) cycles backwards through the matches.

about:debugging (before Firefox 68) - Firefox Developer Tools
service worker state from firefox 52, the list of service workers shows the state of the service worker in its lifecycle.

about:debugging - Firefox Developer Tools
service worker state the list of service workers shows the state of the service worker in its lifecycle.

Background Tasks API - Web APIs
there's no guarantee that every pass through the event loop (or even every screen update cycle) will include any idle callbacks being executed; if the event loop uses all available time, you're out of luck (again, unless you've used a timeout).

Cache - Web APIs
the cache interface provides a storage mechanism for request / response object pairs that are cached, for example as part of the serviceworker life cycle.

DelayNode - Web APIs
when creating a graph that has a cycle, it is mandatory to have at least one delaynode in the cycle, or the nodes taking part in the cycle will be muted.

EffectTiming.delay - Web APIs
syntax var timingproperties = { delay: delayinmilliseconds }; timingproperties.delay = delayinmilliseconds; value a number specifying the delay, in milliseconds, from the start of the animation's play cycle to the beginning of its active interval (the time index at which actual animation begins).

ExtendableEvent - Web APIs
the extendableevent interface extends the lifetime of the install and activate events dispatched on the global scope as part of the service worker lifecycle.

Timing element visibility with the Intersection Observer API - Web APIs
ateadtimer(adbox); if (previoustime != adbox.dataset.totalviewtime) { redrawlist.push(adbox); } }); if (redrawlist.length) { window.requestanimationframe(function(time) { redrawlist.foreach(function(adbox) { drawadtimer(adbox); }); }); } } the array redrawlist will be used to keep a list of all the ads which need to be redrawn during this refresh cycle, since it may not be exactly the same as the elapsed time due to system activity or because you've set the interval to something other than every 1000 milliseconds.

OscillatorNode.type - Web APIs
square a square wave with a duty cycle of 0.5; that is, the signal is "high" for half of each period.

ServiceWorkerGlobalScope - Web APIs
developers should keep in mind that the serviceworker state is not persisted across the termination/restart cycle, so each event handler should assume it's being invoked with a bare, default global state.

URL.revokeObjectURL() - Web APIs
note: this method is not available from service workers, due to issues with the blob interface's life cycle and the potential for leaks.

WebGL best practices - Web APIs
delete objects eagerly don't wait for the garbage collector/cycle collector to realize objects are orphaned and destroy them.

High-level guides - Web APIs
the high-level guides listed below introduce webrtc technology from a top-down perspective, describing the overall architecture, the life cycle of a webrtc connection, and basic security and technological issues you might run into as you explore and build web content or apps using the webrtc api.

Fundamentals of WebXR - Web APIs
webxr application life cycle starting up and shutting down a webxr session movement, orientation, and motion: a webxr example ...

Starting up and shutting down a WebXR session - Web APIs
begin the frame rendering cycle.

WebXR Device API - Web APIs
webxr application life cycle an overview of the overall life cycle of a webxr application, from startup to shutdown.

Visualizations with Web Audio API - Web APIs
var barwidth = (width / bufferlength) * 2.5; var barheight; var x = 0; as before, we now start a for loop and cycle through each value in the dataarray.

The structured clone algorithm - Web APIs
it clones by recursing through the input object while maintaining a map of previously visited references, to avoid infinitely traversing cycles.

Window.requestAnimationFrame() - Web APIs
element.style.transform = 'translatex(' + math.min(0.1 * elapsed, 200) + 'px)'; if (elapsed < 2000) { // stop the animation after 2 seconds window.requestanimationframe(step); } } window.requestanimationframe(step); notes edge versions below 17 and internet explorer do not reliably fire requestanimationframe before the paint cycle.

Window - Web APIs
window.mozanimationstarttime the time in milliseconds since epoch at which the current animation cycle began.

WindowOrWorkerGlobalScope.setTimeout() - Web APIs
if this parameter is omitted, a value of 0 is used, meaning execute "immediately", or more accurately, the next event cycle.

WritableStreamDefaultController.error() - Web APIs
however, it can be useful for suddenly shutting down a stream in response to an event outside the normal lifecycle of interactions with the underlying sink.

Using ARIA: Roles, states, and properties - Accessibility
authors must assign an aria role and the appropriate states and properties to an element during its life-cycle, unless the element already has appropriate aria semantics (via use of an appropriate html element).

HTML To MSAA - Accessibility
m_ text n/a n/a state_system_ readonly if @readonly attribute is used state_system_ protected n/a "activate" n/a input type="checkbox" role_system_ checkbutton n/a n/a state_system_ marqueed used as state checkable state_system_ mixed for html 5 if intermediate property of dom element returns true state_system_ checked if checked property of dom element returns true n/a "check"/"uncheck"/"cycle" depending on state event_object_ statechange when state is changed input type="radio" role_system_ radiobutton n/a n/a state_system_ marqueed used as state checkable state_system_ checked if checked property of dom element returns true n/a "select" event_object_ statechange when state is changed label role_system_ statictext from child nodes n/a n/a n/a n/a n/a legend role_system_ ...

Accessibility documentation index - Accessibility
authors must assign an aria role and the appropriate states and properties to an element during its life-cycle, unless the element already has appropriate aria semantics (via use of an appropriate html element).

CSS values and units - CSS: Cascading Style Sheets
1hz, which can also be written as 1hz or 1hz, is one cycle per second.

animation-delay - CSS: Cascading Style Sheets
a negative value causes the animation to begin immediately, but partway through its cycle.

animation-iteration-count - CSS: Cascading Style Sheets
you may specify non-integer values to play part of an animation cycle: for example, 0.5 will play half of the animation cycle.

animation-timing-function - CSS: Cascading Style Sheets
the animation-timing-function css property sets how an animation progresses through the duration of each cycle.

<integer> - CSS: Cascading Style Sheets
during the css3 values cycle there was a lot of discussion about setting a minimum range to support: the latest decision, in april 2012 during the lc phase, was [-227-1; 227-1], but other values like 224-1 and 230-1 were also proposed.

Touch events (Mozilla experimental) - Developer guides
the stream id is unique until the moztouchup event occurs; after that, the value may be recycled for another series of events.

HTML documentation index - HTML: Hypertext Markup Language
235 preloading content with rel="preload" guide, html, javascript, link, media, performance, web performance, as, preload, rel the preload value of the <link> element's rel attribute lets you declare fetch requests in the html's <head>, specifying resources that your page will need very soon, which you want to start loading early in the page lifecycle, before browsers' main rendering machinery kicks in.

Preloading content with rel="preload" - HTML: Hypertext Markup Language
the preload value of the <link> element's rel attribute lets you declare fetch requests in the html's <head>, specifying resources that your page will need very soon, which you want to start loading early in the page lifecycle, before browsers' main rendering machinery kicks in.

HTML: Hypertext Markup Language
preloading content with rel="preload" the preload value of the <link> element's rel attribute allows you to write declarative fetch requests in your html <head>, specifying resources that your pages will need very soon after loading, which you therefore want to start preloading early in the lifecycle of a page load, before the browser's main rendering machinery kicks in.

Index - HTTP
99 server-timing http, performance, reference, header the server-timing header communicates one or more metrics and descriptions for a given request-response cycle.

Server-Timing - HTTP
the server-timing header communicates one or more metrics and descriptions for a given request-response cycle.

HTTP headers - HTTP
server-timing communicates one or more metrics and descriptions for the given request-response cycle.

HTTP Index - HTTP
180 server-timing http, performance, reference, header the server-timing header communicates one or more metrics and descriptions for a given request-response cycle.

Closures - JavaScript
the loop cycles through these definitions, hooking up an onfocus event to each one that shows the associated help method.

TypeError: cyclic object value - JavaScript
cycle.js) or implement a solution by yourself, which will require finding and replacing (or removing) the cyclic references by serializable values.

Intl.DateTimeFormat.prototype.formatToParts() - JavaScript
chinese and tibetan calendars, for example, use a 60-year sexagenary cycle of named years.

Intl.ListFormat() constructor - JavaScript
const list = ['motorcycle', 'bus', 'car']; console.log(new intl.listformat('en-gb', { style: 'long', type: 'conjunction' }).format(list)); // > motorcycle, bus and car console.log(new intl.listformat('en-gb', { style: 'short', type: 'disjunction' }).format(list)); // > motorcycle, bus or car console.log(new intl.listformat('en-gb', { style: 'narrow', type: 'unit' }).format(list)); // > motorcycle bus car specificat...

Intl​.ListFormat.prototype​.format() - JavaScript
const list = ['motorcycle', 'bus', 'car']; console.log(new intl.listformat('en-gb', { style: 'long', type: 'conjunction' }).format(list)); // > motorcycle, bus and car console.log(new intl.listformat('en-gb', { style: 'short', type: 'disjunction' }).format(list)); // > motorcycle, bus or car console.log(new intl.listformat('en-gb', { style: 'narrow', type: 'unit' }).format(list)); // > motorcycle bus car specifica...

Intl.Locale() constructor - JavaScript
for example, set the hourcycle property of the configuration object to your desired hour cycle type, and then pass it into the constructor: let us12hour = new intl.locale("en-us", {hourcycle: "h12"}); console.log(us12hour.hourcycle); // prints "h12" specifications specification ecmascript internationalization api (ecma-402) ...

Intl.Locale.prototype.baseName - JavaScript
examples basic example let myloc = new intl.locale("fr-latn-ca"); // sets locale to canadian french console.log(myloc.tostring()); // prints out "fr-latn-ca-u-ca-gregory" console.log(myloc.basename); // prints out "fr-latn-ca" example with options in the input string // sets language to japanese, region to japan, // calendar to gregorian, hour cycle to 24 hours let japan = new intl.locale("ja-jp-u-ca-gregory-hc-24"); console.log(japan.tostring()); // prints out "ja-jp-u-ca-gregory-hc-h24" console.log(japan.basename); // prints out "ja-jp" example with options that override input string // input string indicates language as dutch and region as belgium, // but options object overrides the region and sets it to the netherlands let dutch = ne...

Intl.Locale.prototype.toString() - JavaScript
examples using tostring let mylocale = new intl.locale("fr-latn-fr", {hourcycle: "h24", calendar: "gregory"}); console.log(mylocale.basename); // prints "fr-latn-fr" console.log(mylocale.tostring()); // prints "fr-latn-fr-u-ca-gregory-hc-h24" specifications specification ecmascript internationalization api (ecma-402) ...

JSON.stringify() - JavaScript
cycle.js by douglas crockford) or implement a solution by yourself, which will require finding and replacing (or removing) the cyclic references by serializable values.

Object.freeze() - JavaScript
use the pattern on a case-by-case basis based on your design when you know the object contains no cycles in the reference graph, otherwise an endless loop will be triggered.

Reflect.setPrototypeOf() - JavaScript
reflect.setprototypeof(object.freeze({}), null) // false // returns false if it cause a prototype chain cycle.

Performance fundamentals - Web Performance
it tells the browser to render results even while the browser isn't actually drawing; that is, while the video hardware hasn't reached the next display cycle.

Optimizing startup performance - Web Performance
instead, you should write your code so that your app creates a web worker that does as much as possible in a background thread (for example, fetching and processing data.) then, anything that must be done on the main thread (such as user events and rendering ui) should be broken up into small pieces so that the app's event loop continues to cycle while it starts up.

Performance Monitoring: RUM vs synthetic monitoring - Web Performance
rum v synthetic synthetic is well suited for catching regressions during development life cycles, especially with network throttling.

Making PWAs work offline with Service workers - Progressive web apps (PWAs)
lifecycle of a service worker when registration is complete, the sw.js file is automatically downloaded, then installed, and finally activated.

Information Security Basics - Web security
with this information, you can be aware of the role and importance of security throughout the web development cycle and beyond into deployment of your content.

Subdomain takeovers - Web security
preventing subdomain takeovers is a matter of order of operations in lifecycle management for virtual hosts and dns.