From a6c91ebc569110993c7c4130f0456504f624459a Mon Sep 17 00:00:00 2001 From: Sam Gammon Date: Thu, 17 Feb 2022 17:29:47 -0800 Subject: [PATCH] Feature: Closure Support This changeset amends the current copy of IncrementalDOM to work again from Closure and Soy's iDOM compiler. --- .bazelrc | 3 + .bazelversion | 1 + BUILD | 15 +- WORKSPACE | 32 ++ closure/BUILD | 43 +++ closure/index.d.ts | 9 + closure/index.js | 81 +++++ closure/index_es5_tsconfig.json | 1 + closure/src/assertions.d.ts | 86 ++++++ closure/src/assertions.js | 232 +++++++++++++++ closure/src/attributes.d.ts | 37 +++ closure/src/attributes.js | 172 +++++++++++ closure/src/changes.d.ts | 15 + closure/src/changes.js | 57 ++++ closure/src/context.d.ts | 17 ++ closure/src/context.js | 68 +++++ closure/src/core.d.ts | 92 ++++++ closure/src/core.js | 476 ++++++++++++++++++++++++++++++ closure/src/debug.d.ts | 2 + closure/src/debug.js | 13 + closure/src/diff.d.ts | 16 + closure/src/diff.js | 86 ++++++ closure/src/dom_util.d.ts | 30 ++ closure/src/dom_util.js | 127 ++++++++ closure/src/global.d.ts | 5 + closure/src/global.js | 37 +++ closure/src/node_data.d.ts | 80 +++++ closure/src/node_data.js | 226 ++++++++++++++ closure/src/nodes.d.ts | 18 ++ closure/src/nodes.js | 80 +++++ closure/src/notifications.d.ts | 16 + closure/src/notifications.js | 39 +++ closure/src/src_es5_tsconfig.json | 1 + closure/src/symbols.d.ts | 5 + closure/src/symbols.js | 16 + closure/src/types.d.ts | 16 + closure/src/types.js | 43 +++ closure/src/util.d.ts | 27 ++ closure/src/util.js | 66 +++++ closure/src/virtual_elements.d.ts | 96 ++++++ closure/src/virtual_elements.js | 344 +++++++++++++++++++++ external/tsickle.bzl | 41 +++ package-lock.json | 70 +++-- package.json | 11 +- release/BUILD | 3 +- src/BUILD | 5 +- test/BUILD | 1 + tools/BUILD.bazel | 0 tools/ts.bzl | 30 ++ tools/tsc/BUILD.bazel | 21 ++ tsconfig.json | 7 +- 51 files changed, 2984 insertions(+), 31 deletions(-) create mode 100644 .bazelversion create mode 100644 closure/BUILD create mode 100755 closure/index.d.ts create mode 100755 closure/index.js create mode 100755 closure/index_es5_tsconfig.json create mode 100755 closure/src/assertions.d.ts create mode 100755 closure/src/assertions.js create mode 100755 closure/src/attributes.d.ts create mode 100755 closure/src/attributes.js create mode 100755 closure/src/changes.d.ts create mode 100755 closure/src/changes.js create mode 100755 closure/src/context.d.ts create mode 100755 closure/src/context.js create mode 100755 closure/src/core.d.ts create mode 100755 closure/src/core.js create mode 100755 closure/src/debug.d.ts create mode 100755 closure/src/debug.js create mode 100755 closure/src/diff.d.ts create mode 100755 closure/src/diff.js create mode 100755 closure/src/dom_util.d.ts create mode 100755 closure/src/dom_util.js create mode 100755 closure/src/global.d.ts create mode 100755 closure/src/global.js create mode 100755 closure/src/node_data.d.ts create mode 100755 closure/src/node_data.js create mode 100755 closure/src/nodes.d.ts create mode 100755 closure/src/nodes.js create mode 100755 closure/src/notifications.d.ts create mode 100755 closure/src/notifications.js create mode 100755 closure/src/src_es5_tsconfig.json create mode 100755 closure/src/symbols.d.ts create mode 100755 closure/src/symbols.js create mode 100755 closure/src/types.d.ts create mode 100755 closure/src/types.js create mode 100755 closure/src/util.d.ts create mode 100755 closure/src/util.js create mode 100755 closure/src/virtual_elements.d.ts create mode 100755 closure/src/virtual_elements.js create mode 100644 external/tsickle.bzl create mode 100644 tools/BUILD.bazel create mode 100644 tools/ts.bzl create mode 100644 tools/tsc/BUILD.bazel diff --git a/.bazelrc b/.bazelrc index 9cb698bc..9089907f 100644 --- a/.bazelrc +++ b/.bazelrc @@ -58,3 +58,6 @@ try-import %workspace%/.bazelrc.user # It would find the "test/*.ts" reference when compiling //src:src, and the FileCache will then error # when TS attempts to read one of these files that doesn't belong in the compilation. build --worker_sandboxing + +# Don't allow workers for TypeScript compiler +build --strategy=TypeScriptCompile=sandboxed diff --git a/.bazelversion b/.bazelversion new file mode 100644 index 00000000..0062ac97 --- /dev/null +++ b/.bazelversion @@ -0,0 +1 @@ +5.0.0 diff --git a/BUILD b/BUILD index d85beff5..5a264604 100644 --- a/BUILD +++ b/BUILD @@ -1,16 +1,24 @@ package(default_visibility = ["//:__subpackages__"]) -load("@npm//@bazel/typescript:index.bzl", "ts_library") +load("//tools:ts.bzl", "ts_library") load("@build_bazel_rules_nodejs//:index.bzl", "pkg_npm") +load("@io_bazel_rules_closure//closure:defs.bzl", "closure_js_binary") load("@npm//@bazel/rollup:index.bzl", "rollup_bundle") ### Produce umd and cjs bundles ts_library( - name = "dev", + name = "index", srcs = ["index.ts"], - tsickle_typed = True, deps = ["//src"], + package_name = "incrementaldom", + module_name = "incrementaldom", + visibility = ["//visibility:public"], +) + +alias( + name = "dev", + actual = "index", ) [ @@ -81,7 +89,6 @@ genrule( ts_library( name = "release", srcs = [":release_index"], - tsickle_typed = True, deps = ["//release"], ) diff --git a/WORKSPACE b/WORKSPACE index 3d453490..43e705cc 100644 --- a/WORKSPACE +++ b/WORKSPACE @@ -12,6 +12,12 @@ http_archive( urls = ["https://github.com/bazelbuild/rules_nodejs/releases/download/4.6.0/rules_nodejs-4.6.0.tar.gz"], ) +http_archive( + name = "rules_nodejs", + sha256 = "ddb78717b802f8dd5d4c01c340ecdc007c8ced5c1df7db421d0df3d642ea0580", + urls = ["https://github.com/bazelbuild/rules_nodejs/releases/download/4.6.0/rules_nodejs-4.6.0.tar.gz"], +) + load("@build_bazel_rules_nodejs//:index.bzl", "node_repositories") node_repositories(package_json = ["//:package.json"]) @@ -32,6 +38,21 @@ Try running `npm run bazel` instead. minimum_bazel_version = "0.21.0", ) +# Setup Closure tools +http_archive( + name = "io_bazel_rules_closure", + sha256 = "7d206c2383811f378a5ef03f4aacbcf5f47fd8650f6abbc3fa89f3a27dd8b176", + strip_prefix = "rules_closure-0.10.0", + urls = [ + "https://mirror.bazel.build/github.com/bazelbuild/rules_closure/archive/0.10.0.tar.gz", + "https://github.com/bazelbuild/rules_closure/archive/0.10.0.tar.gz", + ], +) + +load("@io_bazel_rules_closure//closure:repositories.bzl", "rules_closure_dependencies", "rules_closure_toolchains") +rules_closure_dependencies() +rules_closure_toolchains() + # Setup the Node.js toolchain & install our npm dependencies into @npm npm_install( name = "npm", @@ -56,3 +77,14 @@ browser_repositories( chromium = True, firefox = True, ) + +# Grab `tsickle` for `tslib` sources +http_archive( + name = "com_google_angular_tsickle_tslib", + sha256 = "1cc046dd9f56041c03ca55f81e580aa1b1a6385fa95ed65abc0d70992231dd5a", + strip_prefix = "tsickle-888aba275b9d7070880b64afbf3534dd55f0f72c/third_party/tslib", + build_file = "tsickle.bzl", + urls = [ + "https://github.com/angular/tsickle/archive/888aba275b9d7070880b64afbf3534dd55f0f72c.tar.gz", + ], +) diff --git a/closure/BUILD b/closure/BUILD new file mode 100644 index 00000000..28aa3264 --- /dev/null +++ b/closure/BUILD @@ -0,0 +1,43 @@ +package( + default_visibility = ["//visibility:public"], +) + +load("@io_bazel_rules_closure//closure:defs.bzl", "closure_js_library", "closure_js_binary") + +IDOM_SUPPRESSIONS = [ + "JSC_REQUIRES_NOT_SORTED", +] + +IDOM_DEPS = [ + "@io_bazel_rules_closure//closure/templates:soy_tslib", +] + + +closure_js_library( + name = "src", + srcs = glob(["src/**/*.js"]), + lenient = True, + deps = IDOM_DEPS, + suppress = IDOM_SUPPRESSIONS, +) + +closure_js_library( + name = "index", + srcs = ["index.js"], + exports = [":src"], + lenient = True, + deps = [":src"] + IDOM_DEPS, + suppress = IDOM_SUPPRESSIONS, +) + +closure_js_binary( + name = "bin", + deps = [":index"] + IDOM_DEPS, + entry_points = ["goog:incrementaldom.index"], + dependency_mode = "PRUNE_LEGACY", +) + +alias( + name = "closure", + actual = "index", +) diff --git a/closure/index.d.ts b/closure/index.d.ts new file mode 100755 index 00000000..48d949bc --- /dev/null +++ b/closure/index.d.ts @@ -0,0 +1,9 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +export { applyAttr, applyProp, attributes, createAttributeMap } from './src/attributes'; +export { alignWithDOM, alwaysDiffAttributes, close, createPatchInner, createPatchOuter, currentElement, currentContext, currentPointer, open, patchInner as patch, patchInner, patchOuter, skip, skipNode, tryGetCurrentElement } from './src/core'; +export { setKeyAttributeName } from './src/global'; +export { clearCache, getKey, importNode, isDataInitialized } from './src/node_data'; +export { notifications } from './src/notifications'; +export { symbols } from './src/symbols'; +export { applyAttrs, applyStatics, attr, elementClose, elementOpen, elementOpenEnd, elementOpenStart, elementVoid, key, text } from './src/virtual_elements'; +export * from './src/types'; diff --git a/closure/index.js b/closure/index.js new file mode 100755 index 00000000..d6920792 --- /dev/null +++ b/closure/index.js @@ -0,0 +1,81 @@ +/** + * @fileoverview added by tsickle + * Generated from: index.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +goog.module('incrementaldom'); +var module = module || { id: 'index.js' }; +goog.require('tslib'); +const tsickle_attributes_1 = goog.requireType("incrementaldom.src.attributes"); +const tsickle_core_2 = goog.requireType("incrementaldom.src.core"); +const tsickle_global_3 = goog.requireType("incrementaldom.src.global"); +const tsickle_node_data_4 = goog.requireType("incrementaldom.src.node_data"); +const tsickle_notifications_5 = goog.requireType("incrementaldom.src.notifications"); +const tsickle_symbols_6 = goog.requireType("incrementaldom.src.symbols"); +const tsickle_virtual_elements_7 = goog.requireType("incrementaldom.src.virtual_elements"); +const tsickle_types_8 = goog.requireType("incrementaldom.src.types"); +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +var attributes_1 = goog.require('incrementaldom.src.attributes'); +exports.applyAttr = attributes_1.applyAttr; +exports.applyProp = attributes_1.applyProp; +exports.attributes = attributes_1.attributes; +exports.createAttributeMap = attributes_1.createAttributeMap; +var core_1 = goog.require('incrementaldom.src.core'); +exports.alignWithDOM = core_1.alignWithDOM; +exports.alwaysDiffAttributes = core_1.alwaysDiffAttributes; +exports.close = core_1.close; +exports.createPatchInner = core_1.createPatchInner; +exports.createPatchOuter = core_1.createPatchOuter; +exports.currentElement = core_1.currentElement; +exports.currentContext = core_1.currentContext; +exports.currentPointer = core_1.currentPointer; +exports.open = core_1.open; +exports.patch = core_1.patchInner; +exports.patchInner = core_1.patchInner; +exports.patchOuter = core_1.patchOuter; +exports.skip = core_1.skip; +exports.skipNode = core_1.skipNode; +exports.tryGetCurrentElement = core_1.tryGetCurrentElement; +var global_1 = goog.require('incrementaldom.src.global'); +exports.setKeyAttributeName = global_1.setKeyAttributeName; +var node_data_1 = goog.require('incrementaldom.src.node_data'); +exports.clearCache = node_data_1.clearCache; +exports.getKey = node_data_1.getKey; +exports.importNode = node_data_1.importNode; +exports.isDataInitialized = node_data_1.isDataInitialized; +var notifications_1 = goog.require('incrementaldom.src.notifications'); +exports.notifications = notifications_1.notifications; +var symbols_1 = goog.require('incrementaldom.src.symbols'); +exports.symbols = symbols_1.symbols; +var virtual_elements_1 = goog.require('incrementaldom.src.virtual_elements'); +exports.applyAttrs = virtual_elements_1.applyAttrs; +exports.applyStatics = virtual_elements_1.applyStatics; +exports.attr = virtual_elements_1.attr; +exports.elementClose = virtual_elements_1.elementClose; +exports.elementOpen = virtual_elements_1.elementOpen; +exports.elementOpenEnd = virtual_elements_1.elementOpenEnd; +exports.elementOpenStart = virtual_elements_1.elementOpenStart; +exports.elementVoid = virtual_elements_1.elementVoid; +exports.key = virtual_elements_1.key; +exports.text = virtual_elements_1.text; +var types_1 = goog.require('incrementaldom.src.types'); +/** @typedef {!tsickle_types_8.ElementConstructor} */ +exports.ElementConstructor; // re-export typedef +/** @typedef {!tsickle_types_8.AttrMutator} */ +exports.AttrMutator; // re-export typedef +/** @typedef {!tsickle_types_8.AttrMutatorConfig} */ +exports.AttrMutatorConfig; // re-export typedef +/** @typedef {!tsickle_types_8.NameOrCtorDef} */ +exports.NameOrCtorDef; // re-export typedef +/** @typedef {!tsickle_types_8.Key} */ +exports.Key; // re-export typedef +/** @typedef {!tsickle_types_8.Statics} */ +exports.Statics; // re-export typedef +/** @typedef {!tsickle_types_8.PatchFunction} */ +exports.PatchFunction; // re-export typedef +/** @typedef {!tsickle_types_8.MatchFnDef} */ +exports.MatchFnDef; // re-export typedef +/** @typedef {!tsickle_types_8.PatchConfig} */ +exports.PatchConfig; // re-export typedef +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFHQSxrRUFBc0Y7QUFBOUUsaUNBQUEsU0FBUyxDQUFBO0FBQUUsaUNBQUEsU0FBUyxDQUFBO0FBQUUsa0NBQUEsVUFBVSxDQUFBO0FBQUUsMENBQUEsa0JBQWtCLENBQUE7QUFDNUQsc0RBQWtQO0FBQTFPLDhCQUFBLFlBQVksQ0FBQTtBQUFFLHNDQUFBLG9CQUFvQixDQUFBO0FBQUUsdUJBQUEsS0FBSyxDQUFBO0FBQUUsa0NBQUEsZ0JBQWdCLENBQUE7QUFBRSxrQ0FBQSxnQkFBZ0IsQ0FBQTtBQUFFLGdDQUFBLGNBQWMsQ0FBQTtBQUFFLGdDQUFBLGNBQWMsQ0FBQTtBQUFFLGdDQUFBLGNBQWMsQ0FBQTtBQUFFLHNCQUFBLElBQUksQ0FBQTtBQUFFLHVCQUFBLFVBQVUsQ0FBUztBQUFFLDRCQUFBLFVBQVUsQ0FBQTtBQUFFLDRCQUFBLFVBQVUsQ0FBQTtBQUFFLHNCQUFBLElBQUksQ0FBQTtBQUFFLDBCQUFBLFFBQVEsQ0FBQTtBQUFFLHNDQUFBLG9CQUFvQixDQUFBO0FBQzlOLDBEQUFpRDtBQUF6Qyx1Q0FBQSxtQkFBbUIsQ0FBQTtBQUMzQixnRUFBaUY7QUFBekUsaUNBQUEsVUFBVSxDQUFBO0FBQUMsNkJBQUEsTUFBTSxDQUFBO0FBQUUsaUNBQUEsVUFBVSxDQUFBO0FBQUUsd0NBQUEsaUJBQWlCLENBQUE7QUFDeEQsd0VBQWtEO0FBQTFDLHdDQUFBLGFBQWEsQ0FBQTtBQUNyQiw0REFBc0M7QUFBOUIsNEJBQUEsT0FBTyxDQUFBO0FBQ2YsOEVBQTJKO0FBQW5KLHdDQUFBLFVBQVUsQ0FBQTtBQUFFLDBDQUFBLFlBQVksQ0FBQTtBQUFFLGtDQUFBLElBQUksQ0FBQTtBQUFFLDBDQUFBLFlBQVksQ0FBQTtBQUFFLHlDQUFBLFdBQVcsQ0FBQTtBQUFFLDRDQUFBLGNBQWMsQ0FBQTtBQUFFLDhDQUFBLGdCQUFnQixDQUFBO0FBQUUseUNBQUEsV0FBVyxDQUFBO0FBQUUsaUNBQUEsR0FBRyxDQUFBO0FBQUUsa0NBQUEsSUFBSSxDQUFBO0FBQzNILHdEQUE0QiIsInNvdXJjZXNDb250ZW50IjpbIi8vICBDb3B5cmlnaHQgMjAxOCBUaGUgSW5jcmVtZW50YWwgRE9NIEF1dGhvcnMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4vKiogQGxpY2Vuc2UgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjAgKi9cblxuZXhwb3J0IHthcHBseUF0dHIsIGFwcGx5UHJvcCwgYXR0cmlidXRlcywgY3JlYXRlQXR0cmlidXRlTWFwfSBmcm9tICcuL3NyYy9hdHRyaWJ1dGVzJztcbmV4cG9ydCB7YWxpZ25XaXRoRE9NLCBhbHdheXNEaWZmQXR0cmlidXRlcywgY2xvc2UsIGNyZWF0ZVBhdGNoSW5uZXIsIGNyZWF0ZVBhdGNoT3V0ZXIsIGN1cnJlbnRFbGVtZW50LCBjdXJyZW50Q29udGV4dCwgY3VycmVudFBvaW50ZXIsIG9wZW4sIHBhdGNoSW5uZXIgYXMgcGF0Y2gsIHBhdGNoSW5uZXIsIHBhdGNoT3V0ZXIsIHNraXAsIHNraXBOb2RlLCB0cnlHZXRDdXJyZW50RWxlbWVudH0gZnJvbSAnLi9zcmMvY29yZSc7XG5leHBvcnQge3NldEtleUF0dHJpYnV0ZU5hbWV9IGZyb20gJy4vc3JjL2dsb2JhbCc7XG5leHBvcnQge2NsZWFyQ2FjaGUsZ2V0S2V5LCBpbXBvcnROb2RlLCBpc0RhdGFJbml0aWFsaXplZH0gZnJvbSAnLi9zcmMvbm9kZV9kYXRhJztcbmV4cG9ydCB7bm90aWZpY2F0aW9uc30gZnJvbSAnLi9zcmMvbm90aWZpY2F0aW9ucyc7XG5leHBvcnQge3N5bWJvbHN9IGZyb20gJy4vc3JjL3N5bWJvbHMnO1xuZXhwb3J0IHthcHBseUF0dHJzLCBhcHBseVN0YXRpY3MsIGF0dHIsIGVsZW1lbnRDbG9zZSwgZWxlbWVudE9wZW4sIGVsZW1lbnRPcGVuRW5kLCBlbGVtZW50T3BlblN0YXJ0LCBlbGVtZW50Vm9pZCwga2V5LCB0ZXh0fSBmcm9tICcuL3NyYy92aXJ0dWFsX2VsZW1lbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vc3JjL3R5cGVzJztcbiJdfQ== \ No newline at end of file diff --git a/closure/index_es5_tsconfig.json b/closure/index_es5_tsconfig.json new file mode 100755 index 00000000..387ec478 --- /dev/null +++ b/closure/index_es5_tsconfig.json @@ -0,0 +1 @@ +{"compilerOptions": {"target": "es2015", "module": "umd", "downlevelIteration": true, "skipDefaultLibCheck": true, "moduleResolution": "node", "outDir": "../../../bazel-out/darwin-fastbuild/bin", "rootDir": "../../..", "rootDirs": ["../../..", "../../../bazel-out/darwin-fastbuild/bin", "../../../bazel-out/darwin-fastbuild/bin"], "baseUrl": "../../..", "paths": {"@incremental_dom/src": ["src", "bazel-out/darwin-fastbuild/bin/src", "bazel-out/darwin-fastbuild/bin/src"], "@incremental_dom/src/*": ["src/*", "bazel-out/darwin-fastbuild/bin/src/*", "bazel-out/darwin-fastbuild/bin/src/*"], "incremental_dom": ["", "bazel-out/darwin-fastbuild/bin/", "bazel-out/darwin-fastbuild/bin/"], "incremental_dom/*": ["./*", "bazel-out/darwin-fastbuild/bin/*", "bazel-out/darwin-fastbuild/bin/*"], "*": ["external/npm/node_modules/*", "external/npm/node_modules/@types/*"]}, "preserveConstEnums": false, "experimentalDecorators": true, "emitDecoratorMetadata": true, "jsx": "react", "noErrorTruncation": false, "noEmitOnError": false, "declaration": true, "declarationDir": "../../../bazel-out/darwin-fastbuild/bin", "stripInternal": true, "inlineSourceMap": true, "inlineSources": true, "sourceMap": false, "typeRoots": ["../../../external/npm/node_modules/@types"], "types": []}, "bazelOptions": {"workspaceName": "incremental_dom", "target": "//:index", "package": "", "tsickleGenerateExterns": true, "tsickleExternsPath": "", "untyped": false, "typeBlackListPaths": [], "ignoreWarningPaths": [], "es5Mode": true, "manifest": "bazel-out/darwin-fastbuild/bin/index.es5.MF", "compilationTargetSrc": ["index.ts"], "addDtsClutzAliases": false, "typeCheckDependencies": false, "expectedDiagnostics": [], "typeCheck": true, "allowedStrictDeps": ["bazel-out/darwin-fastbuild/bin/src/debug.d.ts", "bazel-out/darwin-fastbuild/bin/src/assertions.d.ts", "bazel-out/darwin-fastbuild/bin/src/attributes.d.ts", "bazel-out/darwin-fastbuild/bin/src/changes.d.ts", "bazel-out/darwin-fastbuild/bin/src/context.d.ts", "bazel-out/darwin-fastbuild/bin/src/core.d.ts", "bazel-out/darwin-fastbuild/bin/src/diff.d.ts", "bazel-out/darwin-fastbuild/bin/src/dom_util.d.ts", "bazel-out/darwin-fastbuild/bin/src/global.d.ts", "bazel-out/darwin-fastbuild/bin/src/node_data.d.ts", "bazel-out/darwin-fastbuild/bin/src/nodes.d.ts", "bazel-out/darwin-fastbuild/bin/src/notifications.d.ts", "bazel-out/darwin-fastbuild/bin/src/symbols.d.ts", "bazel-out/darwin-fastbuild/bin/src/types.d.ts", "bazel-out/darwin-fastbuild/bin/src/util.d.ts", "bazel-out/darwin-fastbuild/bin/src/virtual_elements.d.ts", "index.ts"], "moduleName": "incremental_dom", "nodeModulesPrefix": "external/npm/node_modules"}, "files": ["../../../external/npm/node_modules/typescript/lib/protocol.d.ts", "../../../external/npm/node_modules/typescript/lib/tsserverlibrary.d.ts", "../../../external/npm/node_modules/typescript/lib/typescript.d.ts", "../../../external/npm/node_modules/typescript/lib/typescriptServices.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/debug.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/assertions.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/attributes.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/changes.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/context.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/core.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/diff.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/dom_util.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/global.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/node_data.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/nodes.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/notifications.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/symbols.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/types.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/util.d.ts", "../../../bazel-out/darwin-fastbuild/bin/src/virtual_elements.d.ts", "../../../index.ts"], "compileOnSave": false, "extends": "../../../tsconfig"} \ No newline at end of file diff --git a/closure/src/assertions.d.ts b/closure/src/assertions.d.ts new file mode 100755 index 00000000..ba9b0e0b --- /dev/null +++ b/closure/src/assertions.d.ts @@ -0,0 +1,86 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +import { NameOrCtorDef } from "./types"; +/** + * Asserts that a value exists and is not null or undefined. goog.asserts + * is not used in order to avoid dependencies on external code. + * @param val The value to assert is truthy. + * @returns The value. + */ +declare function assert(val: T | null | undefined): T; +/** + * Makes sure that there is a current patch context. + * @param functionName The name of the caller, for the error message. + */ +declare function assertInPatch(functionName: string): void; +/** + * Makes sure that a patch closes every node that it opened. + * @param openElement + * @param root + */ +declare function assertNoUnclosedTags(openElement: Node | null, root: Node | DocumentFragment): void; +/** + * Makes sure that node being outer patched has a parent node. + * @param parent + */ +declare function assertPatchOuterHasParentNode(parent: Node | null): void; +/** + * Makes sure that the caller is not where attributes are expected. + * @param functionName The name of the caller, for the error message. + */ +declare function assertNotInAttributes(functionName: string): void; +/** + * Makes sure that the caller is not inside an element that has declared skip. + * @param functionName The name of the caller, for the error message. + */ +declare function assertNotInSkip(functionName: string): void; +/** + * Makes sure that the caller is where attributes are expected. + * @param functionName The name of the caller, for the error message. + */ +declare function assertInAttributes(functionName: string): void; +/** + * Makes sure the patch closes virtual attributes call + */ +declare function assertVirtualAttributesClosed(): void; +/** + * Makes sure that tags are correctly nested. + * @param currentNameOrCtor + * @param nameOrCtor + */ +declare function assertCloseMatchesOpenTag(currentNameOrCtor: NameOrCtorDef, nameOrCtor: NameOrCtorDef): void; +/** + * Makes sure that no children elements have been declared yet in the current + * element. + * @param functionName The name of the caller, for the error message. + * @param previousNode + */ +declare function assertNoChildrenDeclaredYet(functionName: string, previousNode: Node | null): void; +/** + * Checks that a call to patchOuter actually patched the element. + * @param maybeStartNode The value for the currentNode when the patch + * started. + * @param maybeCurrentNode The currentNode when the patch finished. + * @param expectedNextNode The Node that is expected to follow the + * currentNode after the patch; + * @param expectedPrevNode The Node that is expected to preceed the + * currentNode after the patch. + */ +declare function assertPatchElementNoExtras(maybeStartNode: Node | null, maybeCurrentNode: Node | null, expectedNextNode: Node | null, expectedPrevNode: Node | null): void; +/** + * @param newContext The current patch context. + */ +declare function updatePatchContext(newContext: {} | null): void; +/** + * Updates the state of being in an attribute declaration. + * @param value Whether or not the patch is in an attribute declaration. + * @return the previous value. + */ +declare function setInAttributes(value: boolean): boolean; +/** + * Updates the state of being in a skip element. + * @param value Whether or not the patch is skipping the children of a + * parent node. + * @return the previous value. + */ +declare function setInSkip(value: boolean): boolean; +export { assert, assertInPatch, assertNoUnclosedTags, assertNotInAttributes, assertInAttributes, assertCloseMatchesOpenTag, assertVirtualAttributesClosed, assertNoChildrenDeclaredYet, assertNotInSkip, assertPatchElementNoExtras, assertPatchOuterHasParentNode, setInAttributes, setInSkip, updatePatchContext }; diff --git a/closure/src/assertions.js b/closure/src/assertions.js new file mode 100755 index 00000000..2dd059d6 --- /dev/null +++ b/closure/src/assertions.js @@ -0,0 +1,232 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/assertions.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +goog.module('incrementaldom.src.assertions'); +var module = module || { id: 'src/assertions.js' }; +goog.require('tslib'); +const tsickle_global_1 = goog.requireType("incrementaldom.src.global"); +const tsickle_types_2 = goog.requireType("incrementaldom.src.types"); +// Copyright 2015 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +var global_1 = goog.require('incrementaldom.src.global'); +/** + * Keeps track whether or not we are in an attributes declaration (after + * elementOpenStart, but before elementOpenEnd). + * @type {boolean} + */ +let inAttributes = false; +/** + * Keeps track whether or not we are in an element that should not have its + * children cleared. + * @type {boolean} + */ +let inSkip = false; +/** + * Keeps track of whether or not we are in a patch. + * @type {boolean} + */ +let inPatch = false; +/** + * Asserts that a value exists and is not null or undefined. goog.asserts + * is not used in order to avoid dependencies on external code. + * @template T + * @param {(undefined|null|T)} val The value to assert is truthy. + * @return {T} The value. + */ +function assert(val) { + if (global_1.DEBUG && !val) { + throw new Error("Expected value to be defined"); + } + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + return (/** @type {T} */ (val)); +} +exports.assert = assert; +/** + * Makes sure that there is a current patch context. + * @param {string} functionName The name of the caller, for the error message. + * @return {void} + */ +function assertInPatch(functionName) { + if (!inPatch) { + throw new Error("Cannot call " + functionName + "() unless in patch."); + } +} +exports.assertInPatch = assertInPatch; +/** + * Makes sure that a patch closes every node that it opened. + * @param {(null|!Node)} openElement + * @param {(!Node|!DocumentFragment)} root + * @return {void} + */ +function assertNoUnclosedTags(openElement, root) { + if (openElement === root) { + return; + } + /** @type {(null|!Node)} */ + let currentElement = openElement; + /** @type {!Array} */ + const openTags = []; + while (currentElement && currentElement !== root) { + openTags.push(currentElement.nodeName.toLowerCase()); + currentElement = currentElement.parentNode; + } + throw new Error("One or more tags were not closed:\n" + openTags.join("\n")); +} +exports.assertNoUnclosedTags = assertNoUnclosedTags; +/** + * Makes sure that node being outer patched has a parent node. + * @param {(null|!Node)} parent + * @return {void} + */ +function assertPatchOuterHasParentNode(parent) { + if (!parent) { + console.warn("patchOuter requires the node have a parent if there is a key."); + } +} +exports.assertPatchOuterHasParentNode = assertPatchOuterHasParentNode; +/** + * Makes sure that the caller is not where attributes are expected. + * @param {string} functionName The name of the caller, for the error message. + * @return {void} + */ +function assertNotInAttributes(functionName) { + if (inAttributes) { + throw new Error(functionName + + "() can not be called between " + + "elementOpenStart() and elementOpenEnd()."); + } +} +exports.assertNotInAttributes = assertNotInAttributes; +/** + * Makes sure that the caller is not inside an element that has declared skip. + * @param {string} functionName The name of the caller, for the error message. + * @return {void} + */ +function assertNotInSkip(functionName) { + if (inSkip) { + throw new Error(functionName + + "() may not be called inside an element " + + "that has called skip()."); + } +} +exports.assertNotInSkip = assertNotInSkip; +/** + * Makes sure that the caller is where attributes are expected. + * @param {string} functionName The name of the caller, for the error message. + * @return {void} + */ +function assertInAttributes(functionName) { + if (!inAttributes) { + throw new Error(functionName + + "() can only be called after calling " + + "elementOpenStart()."); + } +} +exports.assertInAttributes = assertInAttributes; +/** + * Makes sure the patch closes virtual attributes call + * @return {void} + */ +function assertVirtualAttributesClosed() { + if (inAttributes) { + throw new Error("elementOpenEnd() must be called after calling " + "elementOpenStart()."); + } +} +exports.assertVirtualAttributesClosed = assertVirtualAttributesClosed; +/** + * Makes sure that tags are correctly nested. + * @param {(string|!tsickle_types_2.ElementConstructor)} currentNameOrCtor + * @param {(string|!tsickle_types_2.ElementConstructor)} nameOrCtor + * @return {void} + */ +function assertCloseMatchesOpenTag(currentNameOrCtor, nameOrCtor) { + if (currentNameOrCtor !== nameOrCtor) { + throw new Error('Received a call to close "' + + nameOrCtor + + '" but "' + + currentNameOrCtor + + '" was open.'); + } +} +exports.assertCloseMatchesOpenTag = assertCloseMatchesOpenTag; +/** + * Makes sure that no children elements have been declared yet in the current + * element. + * @param {string} functionName The name of the caller, for the error message. + * @param {(null|!Node)} previousNode + * @return {void} + */ +function assertNoChildrenDeclaredYet(functionName, previousNode) { + if (previousNode !== null) { + throw new Error(functionName + + "() must come before any child " + + "declarations inside the current element."); + } +} +exports.assertNoChildrenDeclaredYet = assertNoChildrenDeclaredYet; +/** + * Checks that a call to patchOuter actually patched the element. + * @param {(null|!Node)} maybeStartNode The value for the currentNode when the patch + * started. + * @param {(null|!Node)} maybeCurrentNode The currentNode when the patch finished. + * @param {(null|!Node)} expectedNextNode The Node that is expected to follow the + * currentNode after the patch; + * @param {(null|!Node)} expectedPrevNode The Node that is expected to preceed the + * currentNode after the patch. + * @return {void} + */ +function assertPatchElementNoExtras(maybeStartNode, maybeCurrentNode, expectedNextNode, expectedPrevNode) { + /** @type {!Node} */ + const startNode = assert(maybeStartNode); + /** @type {!Node} */ + const currentNode = assert(maybeCurrentNode); + /** @type {boolean} */ + const wasUpdated = currentNode.nextSibling === expectedNextNode && + currentNode.previousSibling === expectedPrevNode; + /** @type {boolean} */ + const wasChanged = currentNode.nextSibling === startNode.nextSibling && + currentNode.previousSibling === expectedPrevNode; + /** @type {boolean} */ + const wasRemoved = currentNode === startNode; + if (!wasUpdated && !wasChanged && !wasRemoved) { + throw new Error("There must be exactly one top level call corresponding " + + "to the patched element."); + } +} +exports.assertPatchElementNoExtras = assertPatchElementNoExtras; +/** + * @param {(null|*)} newContext The current patch context. + * @return {void} + */ +function updatePatchContext(newContext) { + inPatch = newContext != null; +} +exports.updatePatchContext = updatePatchContext; +/** + * Updates the state of being in an attribute declaration. + * @param {boolean} value Whether or not the patch is in an attribute declaration. + * @return {boolean} the previous value. + */ +function setInAttributes(value) { + /** @type {boolean} */ + const previous = inAttributes; + inAttributes = value; + return previous; +} +exports.setInAttributes = setInAttributes; +/** + * Updates the state of being in a skip element. + * @param {boolean} value Whether or not the patch is skipping the children of a + * parent node. + * @return {boolean} the previous value. + */ +function setInSkip(value) { + /** @type {boolean} */ + const previous = inSkip; + inSkip = value; + return previous; +} +exports.setInSkip = setInSkip; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"assertions.js","sourceRoot":"","sources":["../../../../src/assertions.ts"],"names":[],"mappings":"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","sourcesContent":["//  Copyright 2015 The Incremental DOM Authors. All Rights Reserved.\n/** @license SPDX-License-Identifier: Apache-2.0 */\n\nimport { DEBUG } from \"./global\";\nimport { NameOrCtorDef } from \"./types\";\n\n/**\n * Keeps track whether or not we are in an attributes declaration (after\n * elementOpenStart, but before elementOpenEnd).\n */\nlet inAttributes = false;\n\n/**\n * Keeps track whether or not we are in an element that should not have its\n * children cleared.\n */\nlet inSkip = false;\n\n/**\n * Keeps track of whether or not we are in a patch.\n */\nlet inPatch = false;\n\n/**\n * Asserts that a value exists and is not null or undefined. goog.asserts\n * is not used in order to avoid dependencies on external code.\n * @param val The value to assert is truthy.\n * @returns The value.\n */\nfunction assert<T extends {}>(val: T | null | undefined): T {\n  if (DEBUG && !val) {\n    throw new Error(\"Expected value to be defined\");\n  }\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  return val!;\n}\n\n/**\n * Makes sure that there is a current patch context.\n * @param functionName The name of the caller, for the error message.\n */\nfunction assertInPatch(functionName: string) {\n  if (!inPatch) {\n    throw new Error(\"Cannot call \" + functionName + \"() unless in patch.\");\n  }\n}\n\n/**\n * Makes sure that a patch closes every node that it opened.\n * @param openElement\n * @param root\n */\nfunction assertNoUnclosedTags(\n  openElement: Node | null,\n  root: Node | DocumentFragment\n) {\n  if (openElement === root) {\n    return;\n  }\n\n  let currentElement = openElement;\n  const openTags: Array<string> = [];\n  while (currentElement && currentElement !== root) {\n    openTags.push(currentElement.nodeName.toLowerCase());\n    currentElement = currentElement.parentNode;\n  }\n\n  throw new Error(\"One or more tags were not closed:\\n\" + openTags.join(\"\\n\"));\n}\n\n/**\n * Makes sure that node being outer patched has a parent node.\n * @param parent\n */\nfunction assertPatchOuterHasParentNode(parent: Node | null) {\n  if (!parent) {\n    console.warn(\n      \"patchOuter requires the node have a parent if there is a key.\"\n    );\n  }\n}\n\n/**\n * Makes sure that the caller is not where attributes are expected.\n * @param functionName The name of the caller, for the error message.\n */\nfunction assertNotInAttributes(functionName: string) {\n  if (inAttributes) {\n    throw new Error(\n      functionName +\n        \"() can not be called between \" +\n        \"elementOpenStart() and elementOpenEnd().\"\n    );\n  }\n}\n\n/**\n * Makes sure that the caller is not inside an element that has declared skip.\n * @param functionName The name of the caller, for the error message.\n */\nfunction assertNotInSkip(functionName: string) {\n  if (inSkip) {\n    throw new Error(\n      functionName +\n        \"() may not be called inside an element \" +\n        \"that has called skip().\"\n    );\n  }\n}\n\n/**\n * Makes sure that the caller is where attributes are expected.\n * @param functionName The name of the caller, for the error message.\n */\nfunction assertInAttributes(functionName: string) {\n  if (!inAttributes) {\n    throw new Error(\n      functionName +\n        \"() can only be called after calling \" +\n        \"elementOpenStart().\"\n    );\n  }\n}\n\n/**\n * Makes sure the patch closes virtual attributes call\n */\nfunction assertVirtualAttributesClosed() {\n  if (inAttributes) {\n    throw new Error(\n      \"elementOpenEnd() must be called after calling \" + \"elementOpenStart().\"\n    );\n  }\n}\n\n/**\n * Makes sure that tags are correctly nested.\n * @param currentNameOrCtor\n * @param nameOrCtor\n */\nfunction assertCloseMatchesOpenTag(\n  currentNameOrCtor: NameOrCtorDef,\n  nameOrCtor: NameOrCtorDef\n) {\n  if (currentNameOrCtor !== nameOrCtor) {\n    throw new Error(\n      'Received a call to close \"' +\n        nameOrCtor +\n        '\" but \"' +\n        currentNameOrCtor +\n        '\" was open.'\n    );\n  }\n}\n\n/**\n * Makes sure that no children elements have been declared yet in the current\n * element.\n * @param functionName The name of the caller, for the error message.\n * @param previousNode\n */\nfunction assertNoChildrenDeclaredYet(\n  functionName: string,\n  previousNode: Node | null\n) {\n  if (previousNode !== null) {\n    throw new Error(\n      functionName +\n        \"() must come before any child \" +\n        \"declarations inside the current element.\"\n    );\n  }\n}\n\n/**\n * Checks that a call to patchOuter actually patched the element.\n * @param maybeStartNode The value for the currentNode when the patch\n *     started.\n * @param maybeCurrentNode The currentNode when the patch finished.\n * @param expectedNextNode The Node that is expected to follow the\n *    currentNode after the patch;\n * @param expectedPrevNode The Node that is expected to preceed the\n *    currentNode after the patch.\n */\nfunction assertPatchElementNoExtras(\n  maybeStartNode: Node | null,\n  maybeCurrentNode: Node | null,\n  expectedNextNode: Node | null,\n  expectedPrevNode: Node | null\n) {\n  const startNode = assert(maybeStartNode);\n  const currentNode = assert(maybeCurrentNode);\n  const wasUpdated =\n    currentNode.nextSibling === expectedNextNode &&\n    currentNode.previousSibling === expectedPrevNode;\n  const wasChanged =\n    currentNode.nextSibling === startNode.nextSibling &&\n    currentNode.previousSibling === expectedPrevNode;\n  const wasRemoved = currentNode === startNode;\n\n  if (!wasUpdated && !wasChanged && !wasRemoved) {\n    throw new Error(\n      \"There must be exactly one top level call corresponding \" +\n        \"to the patched element.\"\n    );\n  }\n}\n\n/**\n * @param newContext The current patch context.\n */\nfunction updatePatchContext(newContext: {} | null) {\n  inPatch = newContext != null;\n}\n\n/**\n * Updates the state of being in an attribute declaration.\n * @param value Whether or not the patch is in an attribute declaration.\n * @return the previous value.\n */\nfunction setInAttributes(value: boolean) {\n  const previous = inAttributes;\n  inAttributes = value;\n  return previous;\n}\n\n/**\n * Updates the state of being in a skip element.\n * @param value Whether or not the patch is skipping the children of a\n *    parent node.\n * @return the previous value.\n */\nfunction setInSkip(value: boolean) {\n  const previous = inSkip;\n  inSkip = value;\n  return previous;\n}\n\nexport {\n  assert,\n  assertInPatch,\n  assertNoUnclosedTags,\n  assertNotInAttributes,\n  assertInAttributes,\n  assertCloseMatchesOpenTag,\n  assertVirtualAttributesClosed,\n  assertNoChildrenDeclaredYet,\n  assertNotInSkip,\n  assertPatchElementNoExtras,\n  assertPatchOuterHasParentNode,\n  setInAttributes,\n  setInSkip,\n  updatePatchContext\n};\n"]} \ No newline at end of file diff --git a/closure/src/attributes.d.ts b/closure/src/attributes.d.ts new file mode 100755 index 00000000..3ca705b0 --- /dev/null +++ b/closure/src/attributes.d.ts @@ -0,0 +1,37 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +import { AttrMutatorConfig } from "./types"; +/** + * Applies an attribute or property to a given Element. If the value is null + * or undefined, it is removed from the Element. Otherwise, the value is set + * as an attribute. + * @param el The element to apply the attribute to. + * @param name The attribute's name. + * @param value The attribute's value. + */ +declare function applyAttr(el: Element, name: string, value: unknown): void; +/** + * Applies a property to a given Element. + * @param el The element to apply the property to. + * @param name The property's name. + * @param value The property's value. + */ +declare function applyProp(el: Element, name: string, value: unknown): void; +declare function createAttributeMap(): AttrMutatorConfig; +/** + * A publicly mutable object to provide custom mutators for attributes. + * NB: The result of createMap() has to be recast since closure compiler + * will just assume attributes is "any" otherwise and throws away + * the type annotation set by tsickle. + */ +declare const attributes: AttrMutatorConfig; +/** + * Calls the appropriate attribute mutator for this attribute. + * @param el The Element to apply the attribute to. + * @param name The attribute's name. + * @param value The attribute's value. If the value is an object or + * function it is set on the Element, otherwise, it is set as an HTML + * attribute. + * @param attrs The attribute map of mutators. + */ +declare function updateAttribute(el: Element, name: string, value: unknown, attrs: AttrMutatorConfig): void; +export { createAttributeMap, updateAttribute, applyProp, applyAttr, attributes }; diff --git a/closure/src/attributes.js b/closure/src/attributes.js new file mode 100755 index 00000000..d6aec578 --- /dev/null +++ b/closure/src/attributes.js @@ -0,0 +1,172 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/attributes.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +goog.module('incrementaldom.src.attributes'); +var module = module || { id: 'src/attributes.js' }; +goog.require('tslib'); +const tsickle_types_1 = goog.requireType("incrementaldom.src.types"); +const tsickle_assertions_2 = goog.requireType("incrementaldom.src.assertions"); +const tsickle_util_3 = goog.requireType("incrementaldom.src.util"); +const tsickle_symbols_4 = goog.requireType("incrementaldom.src.symbols"); +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +var assertions_1 = goog.require('incrementaldom.src.assertions'); +var util_1 = goog.require('incrementaldom.src.util'); +var symbols_1 = goog.require('incrementaldom.src.symbols'); +/** + * @param {string} name The name of the attribute. For example "tabindex" or + * "xlink:href". + * @return {(null|string)} The namespace to use for the attribute, or null if there is + * no namespace. + */ +function getNamespace(name) { + if (name.lastIndexOf("xml:", 0) === 0) { + return "http://www.w3.org/XML/1998/namespace"; + } + if (name.lastIndexOf("xlink:", 0) === 0) { + return "http://www.w3.org/1999/xlink"; + } + return null; +} +/** + * Applies an attribute or property to a given Element. If the value is null + * or undefined, it is removed from the Element. Otherwise, the value is set + * as an attribute. + * @param {!Element} el The element to apply the attribute to. + * @param {string} name The attribute's name. + * @param {*} value The attribute's value. + * @return {void} + */ +function applyAttr(el, name, value) { + if (value == null) { + el.removeAttribute(name); + } + else { + /** @type {(null|string)} */ + const attrNS = getNamespace(name); + if (attrNS) { + el.setAttributeNS(attrNS, name, (/** @type {string} */ (value))); + } + else { + el.setAttribute(name, (/** @type {string} */ (value))); + } + } +} +exports.applyAttr = applyAttr; +/** + * Applies a property to a given Element. + * @param {!Element} el The element to apply the property to. + * @param {string} name The property's name. + * @param {*} value The property's value. + * @return {void} + */ +function applyProp(el, name, value) { + ((/** @type {?} */ (el)))[name] = value; +} +exports.applyProp = applyProp; +/** + * Applies a value to a style declaration. Supports CSS custom properties by + * setting properties containing a dash using CSSStyleDeclaration.setProperty. + * @param {!CSSStyleDeclaration} style A style declaration. + * @param {string} prop The property to apply. This can be either camelcase or dash + * separated. For example: "backgroundColor" and "background-color" are both + * supported. + * @param {string} value The value of the property. + * @return {void} + */ +function setStyleValue(style, prop, value) { + if (prop.indexOf("-") >= 0) { + style.setProperty(prop, value); + } + else { + ((/** @type {?} */ (style)))[prop] = value; + } +} +/** + * Applies a style to an Element. No vendor prefix expansion is done for + * property names/values. + * @param {!Element} el The Element to apply the style for. + * @param {string} name The attribute's name. + * @param {(string|!Object)} style The style to set. Either a string of css or an object + * containing property-value pairs. + * @return {void} + */ +function applyStyle(el, name, style) { + // MathML elements inherit from Element, which does not have style. We cannot + // do `instanceof HTMLElement` / `instanceof SVGElement`, since el can belong + // to a different document, so just check that it has a style. + assertions_1.assert("style" in el); + /** @type {!CSSStyleDeclaration} */ + const elStyle = ((/** @type {(!HTMLElement|!SVGElement)} */ (el))).style; + if (typeof style === "string") { + elStyle.cssText = style; + } + else { + elStyle.cssText = ""; + for (const prop in style) { + if (util_1.has(style, prop)) { + setStyleValue(elStyle, prop, style[prop]); + } + } + } +} +/** + * Updates a single attribute on an Element. + * @param {!Element} el The Element to apply the attribute to. + * @param {string} name The attribute's name. + * @param {*} value The attribute's value. If the value is an object or + * function it is set on the Element, otherwise, it is set as an HTML + * attribute. + * @return {void} + */ +function applyAttributeTyped(el, name, value) { + /** @type {string} */ + const type = typeof value; + if (type === "object" || type === "function") { + applyProp(el, name, value); + } + else { + applyAttr(el, name, value); + } +} +/** + * @return {!tsickle_types_1.AttrMutatorConfig} + */ +function createAttributeMap() { + /** @type {!tsickle_types_1.AttrMutatorConfig} */ + const attributes = (/** @type {!tsickle_types_1.AttrMutatorConfig} */ (util_1.createMap())); + // Special generic mutator that's called for any attribute that does not + // have a specific mutator. + attributes[symbols_1.symbols.default] = applyAttributeTyped; + attributes["style"] = applyStyle; + return attributes; +} +exports.createAttributeMap = createAttributeMap; +/** + * A publicly mutable object to provide custom mutators for attributes. + * NB: The result of createMap() has to be recast since closure compiler + * will just assume attributes is "any" otherwise and throws away + * the type annotation set by tsickle. + * @type {!tsickle_types_1.AttrMutatorConfig} + */ +const attributes = createAttributeMap(); +exports.attributes = attributes; +/** + * Calls the appropriate attribute mutator for this attribute. + * @param {!Element} el The Element to apply the attribute to. + * @param {string} name The attribute's name. + * @param {*} value The attribute's value. If the value is an object or + * function it is set on the Element, otherwise, it is set as an HTML + * attribute. + * @param {!tsickle_types_1.AttrMutatorConfig} attrs The attribute map of mutators. + * @return {void} + */ +function updateAttribute(el, name, value, attrs) { + /** @type {function(!Element, string, ?): void} */ + const mutator = attrs[name] || attrs[symbols_1.symbols.default]; + mutator(el, name, value); +} +exports.updateAttribute = updateAttribute; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"attributes.js","sourceRoot":"","sources":["../../../../src/attributes.ts"],"names":[],"mappings":"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","sourcesContent":["//  Copyright 2018 The Incremental DOM Authors. All Rights Reserved.\n/** @license SPDX-License-Identifier: Apache-2.0 */\n\nimport { AttrMutatorConfig } from \"./types\";\nimport { assert } from \"./assertions\";\nimport { createMap, has } from \"./util\";\nimport { symbols } from \"./symbols\";\n\n/**\n * @param name The name of the attribute. For example \"tabindex\" or\n *    \"xlink:href\".\n * @returns The namespace to use for the attribute, or null if there is\n * no namespace.\n */\nfunction getNamespace(name: string): string | null {\n  if (name.lastIndexOf(\"xml:\", 0) === 0) {\n    return \"http://www.w3.org/XML/1998/namespace\";\n  }\n\n  if (name.lastIndexOf(\"xlink:\", 0) === 0) {\n    return \"http://www.w3.org/1999/xlink\";\n  }\n\n  return null;\n}\n\n/**\n * Applies an attribute or property to a given Element. If the value is null\n * or undefined, it is removed from the Element. Otherwise, the value is set\n * as an attribute.\n * @param el The element to apply the attribute to.\n * @param name The attribute's name.\n * @param value The attribute's value.\n */\nfunction applyAttr(el: Element, name: string, value: unknown) {\n  if (value == null) {\n    el.removeAttribute(name);\n  } else {\n    const attrNS = getNamespace(name);\n    if (attrNS) {\n      el.setAttributeNS(attrNS, name, value as string);\n    } else {\n      el.setAttribute(name, value as string);\n    }\n  }\n}\n\n/**\n * Applies a property to a given Element.\n * @param el The element to apply the property to.\n * @param name The property's name.\n * @param value The property's value.\n */\nfunction applyProp(el: Element, name: string, value: unknown) {\n  (el as any)[name] = value;\n}\n\n/**\n * Applies a value to a style declaration. Supports CSS custom properties by\n * setting properties containing a dash using CSSStyleDeclaration.setProperty.\n * @param style A style declaration.\n * @param prop The property to apply. This can be either camelcase or dash\n *    separated. For example: \"backgroundColor\" and \"background-color\" are both\n *    supported.\n * @param value The value of the property.\n */\nfunction setStyleValue(\n  style: CSSStyleDeclaration,\n  prop: string,\n  value: string\n) {\n  if (prop.indexOf(\"-\") >= 0) {\n    style.setProperty(prop, value);\n  } else {\n    (style as any)[prop] = value;\n  }\n}\n\n/**\n * Applies a style to an Element. No vendor prefix expansion is done for\n * property names/values.\n * @param el The Element to apply the style for.\n * @param name The attribute's name.\n * @param  style The style to set. Either a string of css or an object\n *     containing property-value pairs.\n */\nfunction applyStyle(\n  el: Element,\n  name: string,\n  style: string | { [k: string]: string }\n) {\n  // MathML elements inherit from Element, which does not have style. We cannot\n  // do `instanceof HTMLElement` / `instanceof SVGElement`, since el can belong\n  // to a different document, so just check that it has a style.\n  assert(\"style\" in el);\n  const elStyle = (<HTMLElement | SVGElement>el).style;\n\n  if (typeof style === \"string\") {\n    elStyle.cssText = style;\n  } else {\n    elStyle.cssText = \"\";\n\n    for (const prop in style) {\n      if (has(style, prop)) {\n        setStyleValue(elStyle, prop, style[prop]);\n      }\n    }\n  }\n}\n\n/**\n * Updates a single attribute on an Element.\n * @param el The Element to apply the attribute to.\n * @param name The attribute's name.\n * @param value The attribute's value. If the value is an object or\n *     function it is set on the Element, otherwise, it is set as an HTML\n *     attribute.\n */\nfunction applyAttributeTyped(el: Element, name: string, value: unknown) {\n  const type = typeof value;\n\n  if (type === \"object\" || type === \"function\") {\n    applyProp(el, name, value);\n  } else {\n    applyAttr(el, name, value);\n  }\n}\n\nfunction createAttributeMap() {\n  const attributes: AttrMutatorConfig = createMap() as AttrMutatorConfig;\n  // Special generic mutator that's called for any attribute that does not\n  // have a specific mutator.\n  attributes[symbols.default] = applyAttributeTyped;\n\n  attributes[\"style\"] = applyStyle;\n  return attributes;\n}\n\n/**\n * A publicly mutable object to provide custom mutators for attributes.\n * NB: The result of createMap() has to be recast since closure compiler\n * will just assume attributes is \"any\" otherwise and throws away\n * the type annotation set by tsickle.\n */\nconst attributes = createAttributeMap();\n\n/**\n * Calls the appropriate attribute mutator for this attribute.\n * @param el The Element to apply the attribute to.\n * @param name The attribute's name.\n * @param value The attribute's value. If the value is an object or\n *     function it is set on the Element, otherwise, it is set as an HTML\n *     attribute.\n * @param attrs The attribute map of mutators.\n */\nfunction updateAttribute(\n  el: Element,\n  name: string,\n  value: unknown,\n  attrs: AttrMutatorConfig\n) {\n  const mutator = attrs[name] || attrs[symbols.default];\n  mutator(el, name, value);\n}\n\nexport {\n  createAttributeMap,\n  updateAttribute,\n  applyProp,\n  applyAttr,\n  attributes\n};\n"]} \ No newline at end of file diff --git a/closure/src/changes.d.ts b/closure/src/changes.d.ts new file mode 100755 index 00000000..255d22bb --- /dev/null +++ b/closure/src/changes.d.ts @@ -0,0 +1,15 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +/** + * TODO(tomnguyen): This is a bit silly and really needs to be better typed. + * @param fn A function to call. + * @param a The first argument to the function. + * @param b The second argument to the function. + * @param c The third argument to the function. + * @param d The fourth argument to the function + */ +declare function queueChange(fn: (a: A, b: B, c: C, d: D) => void, a: A, b: B, c: C, d: D): void; +/** + * Flushes the changes buffer, calling the functions for each change. + */ +declare function flush(): void; +export { queueChange, flush }; diff --git a/closure/src/changes.js b/closure/src/changes.js new file mode 100755 index 00000000..79187bc6 --- /dev/null +++ b/closure/src/changes.js @@ -0,0 +1,57 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/changes.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +goog.module('incrementaldom.src.changes'); +var module = module || { id: 'src/changes.js' }; +goog.require('tslib'); +const tsickle_util_1 = goog.requireType("incrementaldom.src.util"); +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +var util_1 = goog.require('incrementaldom.src.util'); +/** @type {!Array} */ +const buffer = []; +/** @type {number} */ +let bufferStart = 0; +/** + * TODO(tomnguyen): This is a bit silly and really needs to be better typed. + * @template A, B, C, D + * @param {function(A, B, C, D): void} fn A function to call. + * @param {A} a The first argument to the function. + * @param {B} b The second argument to the function. + * @param {C} c The third argument to the function. + * @param {D} d The fourth argument to the function + * @return {void} + */ +function queueChange(fn, a, b, c, d) { + buffer.push(fn); + buffer.push(a); + buffer.push(b); + buffer.push(c); + buffer.push(d); +} +exports.queueChange = queueChange; +/** + * Flushes the changes buffer, calling the functions for each change. + * @return {void} + */ +function flush() { + // A change may cause this function to be called re-entrantly. Keep track of + // the portion of the buffer we are consuming. Updates the start pointer so + // that the next call knows where to start from. + /** @type {number} */ + const start = bufferStart; + /** @type {number} */ + const end = buffer.length; + bufferStart = end; + for (let i = start; i < end; i += 5) { + /** @type {function(?, ?, ?, ?): undefined} */ + const fn = (/** @type {function(?, ?, ?, ?): undefined} */ (buffer[i])); + fn(buffer[i + 1], buffer[i + 2], buffer[i + 3], buffer[i + 4]); + } + bufferStart = start; + util_1.truncateArray(buffer, start); +} +exports.flush = flush; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/closure/src/context.d.ts b/closure/src/context.d.ts new file mode 100755 index 00000000..8e5a47c6 --- /dev/null +++ b/closure/src/context.d.ts @@ -0,0 +1,17 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +/** + * A context object keeps track of the state of a patch. + */ +declare class Context { + private created; + private deleted; + readonly node: Element | DocumentFragment; + constructor(node: Element | DocumentFragment); + markCreated(node: Node): void; + markDeleted(node: Node): void; + /** + * Notifies about nodes that were created during the patch operation. + */ + notifyChanges(): void; +} +export { Context }; diff --git a/closure/src/context.js b/closure/src/context.js new file mode 100755 index 00000000..30adf9f3 --- /dev/null +++ b/closure/src/context.js @@ -0,0 +1,68 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/context.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +goog.module('incrementaldom.src.context'); +var module = module || { id: 'src/context.js' }; +goog.require('tslib'); +const tsickle_notifications_1 = goog.requireType("incrementaldom.src.notifications"); +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +var notifications_1 = goog.require('incrementaldom.src.notifications'); +/** + * A context object keeps track of the state of a patch. + */ +class Context { + /** + * @param {(!DocumentFragment|!Element)} node + */ + constructor(node) { + this.created = []; + this.deleted = []; + this.node = node; + } + /** + * @param {!Node} node + * @return {void} + */ + markCreated(node) { + this.created.push(node); + } + /** + * @param {!Node} node + * @return {void} + */ + markDeleted(node) { + this.deleted.push(node); + } + /** + * Notifies about nodes that were created during the patch operation. + * @return {void} + */ + notifyChanges() { + if (notifications_1.notifications.nodesCreated && this.created.length > 0) { + notifications_1.notifications.nodesCreated(this.created); + } + if (notifications_1.notifications.nodesDeleted && this.deleted.length > 0) { + notifications_1.notifications.nodesDeleted(this.deleted); + } + } +} +exports.Context = Context; +/* istanbul ignore if */ +if (false) { + /** + * @type {!Array} + * @private + */ + Context.prototype.created; + /** + * @type {!Array} + * @private + */ + Context.prototype.deleted; + /** @type {(!DocumentFragment|!Element)} */ + Context.prototype.node; +} +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/closure/src/core.d.ts b/closure/src/core.d.ts new file mode 100755 index 00000000..f55cdee9 --- /dev/null +++ b/closure/src/core.d.ts @@ -0,0 +1,92 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +import { Context } from "./context"; +import { Key, NameOrCtorDef, PatchConfig, PatchFunction } from "./types"; +/** + * TODO(sparhami) We should just export argsBuilder directly when Closure + * Compiler supports ES6 directly. + * @returns The Array used for building arguments. + */ +declare function getArgsBuilder(): Array; +/** + * TODO(sparhami) We should just export attrsBuilder directly when Closure + * Compiler supports ES6 directly. + * @returns The Array used for building arguments. + */ +declare function getAttrsBuilder(): Array; +/** + * Updates the internal structure of a DOM node in the case that an external + * framework tries to modify a DOM element. + * @param el The DOM node to update. + */ +declare function alwaysDiffAttributes(el: Element): void; +/** + * Changes to the next sibling of the current node. + */ +declare function nextNode(): void; +/** + * Aligns the virtual Node definition with the actual DOM, moving the + * corresponding DOM node to the correct location or creating it if necessary. + * @param nameOrCtor The name or constructor for the Node. + * @param key The key used to identify the Node. + * @param nonce The nonce attribute for the element. + */ +declare function alignWithDOM(nameOrCtor: NameOrCtorDef, key: Key, nonce?: string): void; +/** + * Makes sure that the current node is an Element with a matching nameOrCtor and + * key. + * + * @param nameOrCtor The tag or constructor for the Element. + * @param key The key used to identify this element. This can be an + * empty string, but performance may be better if a unique value is used + * when iterating over an array of items. + * @param nonce The nonce attribute for the element. + * @return The corresponding Element. + */ +declare function open(nameOrCtor: NameOrCtorDef, key?: Key, nonce?: string): HTMLElement; +/** + * Closes the currently open Element, removing any unvisited children if + * necessary. + * @returns The Element that was just closed. + */ +declare function close(): Element; +/** + * Makes sure the current node is a Text node and creates a Text node if it is + * not. + * @returns The Text node that was aligned or created. + */ +declare function text(): Text; +/** + * @returns The current Element being patched. + */ +declare function currentElement(): Element; +/** + * @returns The current Element being patched, or null if no patch is in progress. + */ +declare function tryGetCurrentElement(): Element | null; +/** + * @return The Node that will be evaluated for the next instruction. + */ +declare function currentPointer(): Node; +declare function currentContext(): Context | null; +/** + * Skips the children in a subtree, allowing an Element to be closed without + * clearing out the children. + */ +declare function skip(): void; +/** + * Creates a patcher that patches the document starting at node with a + * provided function. This function may be called during an existing patch operation. + * @param patchConfig The config to use for the patch. + * @returns The created function for patching an Element's children. + */ +declare function createPatchInner(patchConfig?: PatchConfig): PatchFunction; +/** + * Creates a patcher that patches an Element with the the provided function. + * Exactly one top level element call should be made corresponding to `node`. + * @param patchConfig The config to use for the patch. + * @returns The created function for patching an Element. + */ +declare function createPatchOuter(patchConfig?: PatchConfig): PatchFunction; +declare const patchInner: (node: Element | DocumentFragment, template: (a: T | undefined) => void, data?: T | undefined) => Node; +declare const patchOuter: (node: Element | DocumentFragment, template: (a: T | undefined) => void, data?: T | undefined) => Node | null; +export { alignWithDOM, alwaysDiffAttributes, getArgsBuilder, getAttrsBuilder, text, createPatchInner, createPatchOuter, patchInner, patchOuter, open, close, currentElement, currentContext, currentPointer, skip, nextNode as skipNode, tryGetCurrentElement }; diff --git a/closure/src/core.js b/closure/src/core.js new file mode 100755 index 00000000..e96ff8fc --- /dev/null +++ b/closure/src/core.js @@ -0,0 +1,476 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/core.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +goog.module('incrementaldom.src.core'); +var module = module || { id: 'src/core.js' }; +goog.require('tslib'); +const tsickle_assertions_1 = goog.requireType("incrementaldom.src.assertions"); +const tsickle_context_2 = goog.requireType("incrementaldom.src.context"); +const tsickle_dom_util_3 = goog.requireType("incrementaldom.src.dom_util"); +const tsickle_global_4 = goog.requireType("incrementaldom.src.global"); +const tsickle_node_data_5 = goog.requireType("incrementaldom.src.node_data"); +const tsickle_nodes_6 = goog.requireType("incrementaldom.src.nodes"); +const tsickle_types_7 = goog.requireType("incrementaldom.src.types"); +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +var assertions_1 = goog.require('incrementaldom.src.assertions'); +var context_1 = goog.require('incrementaldom.src.context'); +var dom_util_1 = goog.require('incrementaldom.src.dom_util'); +var global_1 = goog.require('incrementaldom.src.global'); +var node_data_1 = goog.require('incrementaldom.src.node_data'); +var nodes_1 = goog.require('incrementaldom.src.nodes'); +/** + * The default match function to use, if one was not specified when creating + * the patcher. + * @param {!Node} matchNode The node to match against, unused. + * @param {(string|!tsickle_types_7.ElementConstructor)} nameOrCtor The name or constructor as declared. + * @param {(string|!tsickle_types_7.ElementConstructor)} expectedNameOrCtor The name or constructor of the existing node. + * @param {(undefined|null|string|number)} key The key as declared. + * @param {(undefined|null|string|number)} expectedKey The key of the existing node. + * @return {boolean} True if the node matches, false otherwise. + */ +function defaultMatchFn(matchNode, nameOrCtor, expectedNameOrCtor, key, expectedKey) { + // Key check is done using double equals as we want to treat a null key the + // same as undefined. This should be okay as the only values allowed are + // strings, null and undefined so the == semantics are not too weird. + return nameOrCtor == expectedNameOrCtor && key == expectedKey; +} +/** @type {(null|!tsickle_context_2.Context)} */ +let context = null; +/** @type {(null|!Node)} */ +let currentNode = null; +/** @type {(null|!Node)} */ +let currentParent = null; +/** @type {(null|!Document)} */ +let doc = null; +/** @type {!Array} */ +let focusPath = []; +/** @type {function(!Node, (string|!tsickle_types_7.ElementConstructor), (string|!tsickle_types_7.ElementConstructor), (undefined|null|string|number), (undefined|null|string|number)): boolean} */ +let matchFn = defaultMatchFn; +/** + * Used to build up call arguments. Each patch call gets a separate copy, so + * this works with nested calls to patch. + * @type {!Array<(undefined|null|*)>} + */ +let argsBuilder = []; +/** + * Used to build up attrs for the an element. + * @type {!Array} + */ +let attrsBuilder = []; +/** + * TODO(sparhami) We should just export argsBuilder directly when Closure + * Compiler supports ES6 directly. + * @return {!Array} The Array used for building arguments. + */ +function getArgsBuilder() { + return argsBuilder; +} +exports.getArgsBuilder = getArgsBuilder; +/** + * TODO(sparhami) We should just export attrsBuilder directly when Closure + * Compiler supports ES6 directly. + * @return {!Array} The Array used for building arguments. + */ +function getAttrsBuilder() { + return attrsBuilder; +} +exports.getAttrsBuilder = getAttrsBuilder; +/** + * Checks whether or not the current node matches the specified nameOrCtor and + * key. This uses the specified match function when creating the patcher. + * @param {!Node} matchNode A node to match the data to. + * @param {(string|!tsickle_types_7.ElementConstructor)} nameOrCtor The name or constructor to check for. + * @param {(undefined|null|string|number)} key The key used to identify the Node. + * @return {boolean} True if the node matches, false otherwise. + */ +function matches(matchNode, nameOrCtor, key) { + /** @type {!tsickle_node_data_5.NodeData} */ + const data = node_data_1.getData(matchNode, key); + return matchFn(matchNode, nameOrCtor, data.nameOrCtor, key, data.key); +} +/** + * Finds the matching node, starting at `node` and looking at the subsequent + * siblings if a key is used. + * @param {(null|!Node)} matchNode The node to start looking at. + * @param {(string|!tsickle_types_7.ElementConstructor)} nameOrCtor The name or constructor for the Node. + * @param {(undefined|null|string|number)} key The key used to identify the Node. + * @return {(null|!Node)} The matching Node, if any exists. + */ +function getMatchingNode(matchNode, nameOrCtor, key) { + if (!matchNode) { + return null; + } + /** @type {(null|!Node)} */ + let cur = matchNode; + do { + if (matches(cur, nameOrCtor, key)) { + return cur; + } + } while (key && (cur = cur.nextSibling)); + return null; +} +/** + * Updates the internal structure of a DOM node in the case that an external + * framework tries to modify a DOM element. + * @param {!Element} el The DOM node to update. + * @return {void} + */ +function alwaysDiffAttributes(el) { + node_data_1.getData(el).alwaysDiffAttributes = true; +} +exports.alwaysDiffAttributes = alwaysDiffAttributes; +/** + * Clears out any unvisited Nodes in a given range. + * @param {(null|!Node)} maybeParentNode + * @param {(null|!Node)} startNode The node to start clearing from, inclusive. + * @param {(null|!Node)} endNode The node to clear until, exclusive. + * @return {void} + */ +function clearUnvisitedDOM(maybeParentNode, startNode, endNode) { + /** @type {!Node} */ + const parentNode = (/** @type {!Node} */ (maybeParentNode)); + /** @type {(null|!Node)} */ + let child = startNode; + while (child !== endNode) { + /** @type {(null|!ChildNode)} */ + const next = (/** @type {!Node} */ (child)).nextSibling; + parentNode.removeChild((/** @type {!Node} */ (child))); + (/** @type {!tsickle_context_2.Context} */ (context)).markDeleted((/** @type {!Node} */ (child))); + child = next; + } +} +/** + * @return {(null|!Node)} The next Node to be patched. + */ +function getNextNode() { + if (currentNode) { + return currentNode.nextSibling; + } + else { + return (/** @type {!Node} */ (currentParent)).firstChild; + } +} +/** + * Changes to the first child of the current node. + * @return {void} + */ +function enterNode() { + currentParent = currentNode; + currentNode = null; +} +/** + * Changes to the parent of the current node, removing any unvisited children. + * @return {void} + */ +function exitNode() { + clearUnvisitedDOM(currentParent, getNextNode(), null); + currentNode = currentParent; + currentParent = (/** @type {!Node} */ (currentParent)).parentNode; +} +/** + * Changes to the next sibling of the current node. + * @return {void} + */ +function nextNode() { + currentNode = getNextNode(); +} +exports.skipNode = nextNode; +/** + * Creates a Node and marking it as created. + * @param {(string|!tsickle_types_7.ElementConstructor)} nameOrCtor The name or constructor for the Node. + * @param {(undefined|null|string|number)} key The key used to identify the Node. + * @param {(undefined|string)=} nonce The nonce attribute for the element. + * @return {!Node} The newly created node. + */ +function createNode(nameOrCtor, key, nonce) { + /** @type {?} */ + let node; + if (nameOrCtor === "#text") { + node = nodes_1.createText((/** @type {!Document} */ (doc))); + } + else { + node = nodes_1.createElement((/** @type {!Document} */ (doc)), (/** @type {!Node} */ (currentParent)), nameOrCtor, key); + if (nonce) { + node.setAttribute("nonce", nonce); + } + } + (/** @type {!tsickle_context_2.Context} */ (context)).markCreated(node); + return node; +} +/** + * Aligns the virtual Node definition with the actual DOM, moving the + * corresponding DOM node to the correct location or creating it if necessary. + * @param {(string|!tsickle_types_7.ElementConstructor)} nameOrCtor The name or constructor for the Node. + * @param {(undefined|null|string|number)} key The key used to identify the Node. + * @param {(undefined|string)=} nonce The nonce attribute for the element. + * @return {void} + */ +function alignWithDOM(nameOrCtor, key, nonce) { + nextNode(); + /** @type {(null|!Node)} */ + const existingNode = getMatchingNode(currentNode, nameOrCtor, key); + /** @type {!Node} */ + const node = existingNode || createNode(nameOrCtor, key, nonce); + // If we are at the matching node, then we are done. + if (node === currentNode) { + return; + } + // Re-order the node into the right position, preserving focus if either + // node or currentNode are focused by making sure that they are not detached + // from the DOM. + if (focusPath.indexOf(node) >= 0) { + // Move everything else before the node. + dom_util_1.moveBefore((/** @type {!Node} */ (currentParent)), node, currentNode); + } + else { + (/** @type {!Node} */ (currentParent)).insertBefore(node, currentNode); + } + currentNode = node; +} +exports.alignWithDOM = alignWithDOM; +/** + * Makes sure that the current node is an Element with a matching nameOrCtor and + * key. + * + * @param {(string|!tsickle_types_7.ElementConstructor)} nameOrCtor The tag or constructor for the Element. + * @param {(undefined|null|string|number)=} key The key used to identify this element. This can be an + * empty string, but performance may be better if a unique value is used + * when iterating over an array of items. + * @param {(undefined|string)=} nonce The nonce attribute for the element. + * @return {!HTMLElement} The corresponding Element. + */ +function open(nameOrCtor, key, nonce) { + alignWithDOM(nameOrCtor, key, nonce); + enterNode(); + return (/** @type {!HTMLElement} */ (currentParent)); +} +exports.open = open; +/** + * Closes the currently open Element, removing any unvisited children if + * necessary. + * @return {!Element} The Element that was just closed. + */ +function close() { + if (global_1.DEBUG) { + assertions_1.setInSkip(false); + } + exitNode(); + return (/** @type {!Element} */ (currentNode)); +} +exports.close = close; +/** + * Makes sure the current node is a Text node and creates a Text node if it is + * not. + * @return {!Text} The Text node that was aligned or created. + */ +function text() { + alignWithDOM("#text", null); + return (/** @type {!Text} */ (currentNode)); +} +exports.text = text; +/** + * @return {!Element} The current Element being patched. + */ +function currentElement() { + if (global_1.DEBUG) { + assertions_1.assertInPatch("currentElement"); + assertions_1.assertNotInAttributes("currentElement"); + } + return (/** @type {!Element} */ (currentParent)); +} +exports.currentElement = currentElement; +/** + * @return {(null|!Element)} The current Element being patched, or null if no patch is in progress. + */ +function tryGetCurrentElement() { + return (/** @type {(null|!Element)} */ (currentParent)); +} +exports.tryGetCurrentElement = tryGetCurrentElement; +/** + * @return {!Node} The Node that will be evaluated for the next instruction. + */ +function currentPointer() { + if (global_1.DEBUG) { + assertions_1.assertInPatch("currentPointer"); + assertions_1.assertNotInAttributes("currentPointer"); + } + // TODO(tomnguyen): assert that this is not null + return (/** @type {!Node} */ (getNextNode())); +} +exports.currentPointer = currentPointer; +/** + * @return {(null|!tsickle_context_2.Context)} + */ +function currentContext() { + return context; +} +exports.currentContext = currentContext; +/** + * Skips the children in a subtree, allowing an Element to be closed without + * clearing out the children. + * @return {void} + */ +function skip() { + if (global_1.DEBUG) { + assertions_1.assertNoChildrenDeclaredYet("skip", currentNode); + assertions_1.setInSkip(true); + } + currentNode = (/** @type {!Node} */ (currentParent)).lastChild; +} +exports.skip = skip; +/** + * Returns a patcher function that sets up and restores a patch context, + * running the run function with the provided data. + * @template T, R + * @param {function((!DocumentFragment|!Element), function((undefined|T)): void, (undefined|T)=): R} run The function that will run the patch. + * @param {!tsickle_types_7.PatchConfig=} patchConfig The configuration to use for the patch. + * @return {function((!DocumentFragment|!Element), function((undefined|T)): void, (undefined|T)=): R} The created patch function. + */ +function createPatcher(run, patchConfig = {}) { + const { matches = defaultMatchFn } = patchConfig; + /** @type {function((!DocumentFragment|!Element), function((undefined|T)): void, (undefined|T)=): R} */ + const f = (/** + * @param {(!DocumentFragment|!Element)} node + * @param {function((undefined|T)): void} fn + * @param {(undefined|T)} data + * @return {R} + */ + (node, fn, data) => { + /** @type {(null|!tsickle_context_2.Context)} */ + const prevContext = context; + /** @type {(null|!Document)} */ + const prevDoc = doc; + /** @type {!Array} */ + const prevFocusPath = focusPath; + /** @type {!Array<(undefined|null|*)>} */ + const prevArgsBuilder = argsBuilder; + /** @type {!Array} */ + const prevAttrsBuilder = attrsBuilder; + /** @type {(null|!Node)} */ + const prevCurrentNode = currentNode; + /** @type {(null|!Node)} */ + const prevCurrentParent = currentParent; + /** @type {function(!Node, (string|!tsickle_types_7.ElementConstructor), (string|!tsickle_types_7.ElementConstructor), (undefined|null|string|number), (undefined|null|string|number)): boolean} */ + const prevMatchFn = matchFn; + /** @type {boolean} */ + let previousInAttributes = false; + /** @type {boolean} */ + let previousInSkip = false; + doc = node.ownerDocument; + context = new context_1.Context(node); + matchFn = matches; + argsBuilder = []; + attrsBuilder = []; + currentNode = null; + currentParent = node.parentNode; + focusPath = dom_util_1.getFocusedPath(node, currentParent); + if (global_1.DEBUG) { + previousInAttributes = assertions_1.setInAttributes(false); + previousInSkip = assertions_1.setInSkip(false); + assertions_1.updatePatchContext(context); + } + try { + /** @type {R} */ + const retVal = run(node, fn, data); + if (global_1.DEBUG) { + assertions_1.assertVirtualAttributesClosed(); + } + return retVal; + } + finally { + context.notifyChanges(); + doc = prevDoc; + context = prevContext; + matchFn = prevMatchFn; + argsBuilder = prevArgsBuilder; + attrsBuilder = prevAttrsBuilder; + currentNode = prevCurrentNode; + currentParent = prevCurrentParent; + focusPath = prevFocusPath; + // Needs to be done after assertions because assertions rely on state + // from these methods. + if (global_1.DEBUG) { + assertions_1.setInAttributes(previousInAttributes); + assertions_1.setInSkip(previousInSkip); + assertions_1.updatePatchContext(context); + } + } + }); + return f; +} +/** + * Creates a patcher that patches the document starting at node with a + * provided function. This function may be called during an existing patch operation. + * @template T + * @param {(undefined|!tsickle_types_7.PatchConfig)=} patchConfig The config to use for the patch. + * @return {function((!DocumentFragment|!Element), function((undefined|T)): void, (undefined|T)=): !Node} The created function for patching an Element's children. + */ +function createPatchInner(patchConfig) { + return createPatcher((/** + * @param {(!DocumentFragment|!Element)} node + * @param {function((undefined|T)): void} fn + * @param {(undefined|T)} data + * @return {(!DocumentFragment|!Element)} + */ + (node, fn, data) => { + currentNode = node; + enterNode(); + fn(data); + exitNode(); + if (global_1.DEBUG) { + assertions_1.assertNoUnclosedTags(currentNode, node); + } + return node; + }), patchConfig); +} +exports.createPatchInner = createPatchInner; +/** + * Creates a patcher that patches an Element with the the provided function. + * Exactly one top level element call should be made corresponding to `node`. + * @template T + * @param {(undefined|!tsickle_types_7.PatchConfig)=} patchConfig The config to use for the patch. + * @return {function((!DocumentFragment|!Element), function((undefined|T)): void, (undefined|T)=): (null|!Node)} The created function for patching an Element. + */ +function createPatchOuter(patchConfig) { + return createPatcher((/** + * @param {(!DocumentFragment|!Element)} node + * @param {function((undefined|T)): void} fn + * @param {(undefined|T)} data + * @return {(null|!Node)} + */ + (node, fn, data) => { + /** @type {!Element} */ + const startNode = (/** @type {!Element} */ (((/** @type {?} */ ({ nextSibling: node }))))); + /** @type {(null|!Node)} */ + let expectedNextNode = null; + /** @type {(null|!Node)} */ + let expectedPrevNode = null; + if (global_1.DEBUG) { + expectedNextNode = node.nextSibling; + expectedPrevNode = node.previousSibling; + } + currentNode = startNode; + fn(data); + if (global_1.DEBUG) { + if (node_data_1.getData(node).key) { + assertions_1.assertPatchOuterHasParentNode(currentParent); + } + assertions_1.assertPatchElementNoExtras(startNode, currentNode, expectedNextNode, expectedPrevNode); + } + if (currentParent) { + clearUnvisitedDOM(currentParent, getNextNode(), node.nextSibling); + } + return startNode === currentNode ? null : currentNode; + }), patchConfig); +} +exports.createPatchOuter = createPatchOuter; +/** @type {function((!DocumentFragment|!Element), function((undefined|?)): void, (undefined|?)=): !Node} */ +const patchInner = createPatchInner(); +exports.patchInner = patchInner; +/** @type {function((!DocumentFragment|!Element), function((undefined|?)): void, (undefined|?)=): (null|!Node)} */ +const patchOuter = createPatchOuter(); +exports.patchOuter = patchOuter; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../../src/core.ts"],"names":[],"mappings":"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","sourcesContent":["//  Copyright 2018 The Incremental DOM Authors. All Rights Reserved.\n/** @license SPDX-License-Identifier: Apache-2.0 */\n\nimport {\n  assertInPatch,\n  assertNoChildrenDeclaredYet,\n  assertNotInAttributes,\n  assertNoUnclosedTags,\n  assertPatchElementNoExtras,\n  assertPatchOuterHasParentNode,\n  assertVirtualAttributesClosed,\n  setInAttributes,\n  setInSkip,\n  updatePatchContext\n} from \"./assertions\";\nimport { Context } from \"./context\";\nimport { getFocusedPath, moveBefore } from \"./dom_util\";\nimport { DEBUG } from \"./global\";\nimport { getData } from \"./node_data\";\nimport { createElement, createText } from \"./nodes\";\nimport {\n  Key,\n  MatchFnDef,\n  NameOrCtorDef,\n  PatchConfig,\n  PatchFunction\n} from \"./types\";\n\n/**\n * The default match function to use, if one was not specified when creating\n * the patcher.\n * @param matchNode The node to match against, unused.\n * @param nameOrCtor The name or constructor as declared.\n * @param expectedNameOrCtor The name or constructor of the existing node.\n * @param key The key as declared.\n * @param expectedKey The key of the existing node.\n * @returns True if the node matches, false otherwise.\n */\nfunction defaultMatchFn(\n  matchNode: Node,\n  nameOrCtor: NameOrCtorDef,\n  expectedNameOrCtor: NameOrCtorDef,\n  key: Key,\n  expectedKey: Key\n): boolean {\n  // Key check is done using double equals as we want to treat a null key the\n  // same as undefined. This should be okay as the only values allowed are\n  // strings, null and undefined so the == semantics are not too weird.\n  return nameOrCtor == expectedNameOrCtor && key == expectedKey;\n}\n\nlet context: Context | null = null;\n\nlet currentNode: Node | null = null;\n\nlet currentParent: Node | null = null;\n\nlet doc: Document | null = null;\n\nlet focusPath: Array<Node> = [];\n\nlet matchFn: MatchFnDef = defaultMatchFn;\n\n/**\n * Used to build up call arguments. Each patch call gets a separate copy, so\n * this works with nested calls to patch.\n */\nlet argsBuilder: Array<{} | null | undefined> = [];\n\n/**\n * Used to build up attrs for the an element.\n */\nlet attrsBuilder: Array<any> = [];\n\n/**\n * TODO(sparhami) We should just export argsBuilder directly when Closure\n * Compiler supports ES6 directly.\n * @returns The Array used for building arguments.\n */\nfunction getArgsBuilder(): Array<any> {\n  return argsBuilder;\n}\n\n/**\n * TODO(sparhami) We should just export attrsBuilder directly when Closure\n * Compiler supports ES6 directly.\n * @returns The Array used for building arguments.\n */\nfunction getAttrsBuilder(): Array<any> {\n  return attrsBuilder;\n}\n\n/**\n * Checks whether or not the current node matches the specified nameOrCtor and\n * key. This uses the specified match function when creating the patcher.\n * @param matchNode A node to match the data to.\n * @param nameOrCtor The name or constructor to check for.\n * @param key The key used to identify the Node.\n * @return True if the node matches, false otherwise.\n */\nfunction matches(\n  matchNode: Node,\n  nameOrCtor: NameOrCtorDef,\n  key: Key\n): boolean {\n  const data = getData(matchNode, key);\n\n  return matchFn(matchNode, nameOrCtor, data.nameOrCtor, key, data.key);\n}\n\n/**\n * Finds the matching node, starting at `node` and looking at the subsequent\n * siblings if a key is used.\n * @param matchNode The node to start looking at.\n * @param nameOrCtor The name or constructor for the Node.\n * @param key The key used to identify the Node.\n * @returns The matching Node, if any exists.\n */\nfunction getMatchingNode(\n  matchNode: Node | null,\n  nameOrCtor: NameOrCtorDef,\n  key: Key\n): Node | null {\n  if (!matchNode) {\n    return null;\n  }\n\n  let cur: Node | null = matchNode;\n\n  do {\n    if (matches(cur, nameOrCtor, key)) {\n      return cur;\n    }\n  } while (key && (cur = cur.nextSibling));\n\n  return null;\n}\n\n/**\n * Updates the internal structure of a DOM node in the case that an external\n * framework tries to modify a DOM element.\n * @param el The DOM node to update.\n */\nfunction alwaysDiffAttributes(el: Element) {\n  getData(el).alwaysDiffAttributes = true;\n}\n\n/**\n * Clears out any unvisited Nodes in a given range.\n * @param maybeParentNode\n * @param startNode The node to start clearing from, inclusive.\n * @param endNode The node to clear until, exclusive.\n */\nfunction clearUnvisitedDOM(\n  maybeParentNode: Node | null,\n  startNode: Node | null,\n  endNode: Node | null\n) {\n  const parentNode = maybeParentNode!;\n  let child = startNode;\n\n  while (child !== endNode) {\n    const next = child!.nextSibling;\n    parentNode.removeChild(child!);\n    context!.markDeleted(child!);\n    child = next;\n  }\n}\n\n/**\n * @return The next Node to be patched.\n */\nfunction getNextNode(): Node | null {\n  if (currentNode) {\n    return currentNode.nextSibling;\n  } else {\n    return currentParent!.firstChild;\n  }\n}\n\n/**\n * Changes to the first child of the current node.\n */\nfunction enterNode() {\n  currentParent = currentNode;\n  currentNode = null;\n}\n\n/**\n * Changes to the parent of the current node, removing any unvisited children.\n */\nfunction exitNode() {\n  clearUnvisitedDOM(currentParent, getNextNode(), null);\n\n  currentNode = currentParent;\n  currentParent = currentParent!.parentNode;\n}\n\n/**\n * Changes to the next sibling of the current node.\n */\nfunction nextNode() {\n  currentNode = getNextNode();\n}\n\n/**\n * Creates a Node and marking it as created.\n * @param nameOrCtor The name or constructor for the Node.\n * @param key The key used to identify the Node.\n * @param nonce The nonce attribute for the element.\n * @return The newly created node.\n */\nfunction createNode(nameOrCtor: NameOrCtorDef, key: Key, nonce?: string): Node {\n  let node;\n\n  if (nameOrCtor === \"#text\") {\n    node = createText(doc!);\n  } else {\n    node = createElement(doc!, currentParent!, nameOrCtor, key);\n    if (nonce) {\n      node.setAttribute(\"nonce\", nonce);\n    }\n  }\n\n  context!.markCreated(node);\n\n  return node;\n}\n\n/**\n * Aligns the virtual Node definition with the actual DOM, moving the\n * corresponding DOM node to the correct location or creating it if necessary.\n * @param nameOrCtor The name or constructor for the Node.\n * @param key The key used to identify the Node.\n * @param nonce The nonce attribute for the element.\n */\nfunction alignWithDOM(nameOrCtor: NameOrCtorDef, key: Key, nonce?: string) {\n  nextNode();\n  const existingNode = getMatchingNode(currentNode, nameOrCtor, key);\n  const node = existingNode || createNode(nameOrCtor, key, nonce);\n\n  // If we are at the matching node, then we are done.\n  if (node === currentNode) {\n    return;\n  }\n\n  // Re-order the node into the right position, preserving focus if either\n  // node or currentNode are focused by making sure that they are not detached\n  // from the DOM.\n  if (focusPath.indexOf(node) >= 0) {\n    // Move everything else before the node.\n    moveBefore(currentParent!, node, currentNode);\n  } else {\n    currentParent!.insertBefore(node, currentNode);\n  }\n\n  currentNode = node;\n}\n\n/**\n * Makes sure that the current node is an Element with a matching nameOrCtor and\n * key.\n *\n * @param nameOrCtor The tag or constructor for the Element.\n * @param key The key used to identify this element. This can be an\n *     empty string, but performance may be better if a unique value is used\n *     when iterating over an array of items.\n * @param nonce The nonce attribute for the element.\n * @return The corresponding Element.\n */\nfunction open(\n  nameOrCtor: NameOrCtorDef,\n  key?: Key,\n  nonce?: string\n): HTMLElement {\n  alignWithDOM(nameOrCtor, key, nonce);\n  enterNode();\n  return currentParent as HTMLElement;\n}\n\n/**\n * Closes the currently open Element, removing any unvisited children if\n * necessary.\n * @returns The Element that was just closed.\n */\nfunction close(): Element {\n  if (DEBUG) {\n    setInSkip(false);\n  }\n\n  exitNode();\n  return currentNode as Element;\n}\n\n/**\n * Makes sure the current node is a Text node and creates a Text node if it is\n * not.\n * @returns The Text node that was aligned or created.\n */\nfunction text(): Text {\n  alignWithDOM(\"#text\", null);\n  return currentNode as Text;\n}\n\n/**\n * @returns The current Element being patched.\n */\nfunction currentElement(): Element {\n  if (DEBUG) {\n    assertInPatch(\"currentElement\");\n    assertNotInAttributes(\"currentElement\");\n  }\n  return currentParent as Element;\n}\n\n/**\n * @returns The current Element being patched, or null if no patch is in progress.\n */\nfunction tryGetCurrentElement(): Element | null {\n  return currentParent as Element | null;\n}\n\n/**\n * @return The Node that will be evaluated for the next instruction.\n */\nfunction currentPointer(): Node {\n  if (DEBUG) {\n    assertInPatch(\"currentPointer\");\n    assertNotInAttributes(\"currentPointer\");\n  }\n  // TODO(tomnguyen): assert that this is not null\n  return getNextNode()!;\n}\n\nfunction currentContext() {\n  return context;\n}\n\n/**\n * Skips the children in a subtree, allowing an Element to be closed without\n * clearing out the children.\n */\nfunction skip() {\n  if (DEBUG) {\n    assertNoChildrenDeclaredYet(\"skip\", currentNode);\n    setInSkip(true);\n  }\n  currentNode = currentParent!.lastChild;\n}\n\n/**\n * Returns a patcher function that sets up and restores a patch context,\n * running the run function with the provided data.\n * @param run The function that will run the patch.\n * @param patchConfig The configuration to use for the patch.\n * @returns The created patch function.\n */\nfunction createPatcher<T, R>(\n  run: PatchFunction<T, R>,\n  patchConfig: PatchConfig = {}\n): PatchFunction<T, R> {\n  const { matches = defaultMatchFn } = patchConfig;\n\n  const f: PatchFunction<T, R> = (node, fn, data) => {\n    const prevContext = context;\n    const prevDoc = doc;\n    const prevFocusPath = focusPath;\n    const prevArgsBuilder = argsBuilder;\n    const prevAttrsBuilder = attrsBuilder;\n    const prevCurrentNode = currentNode;\n    const prevCurrentParent = currentParent;\n    const prevMatchFn = matchFn;\n    let previousInAttributes = false;\n    let previousInSkip = false;\n\n    doc = node.ownerDocument;\n    context = new Context(node);\n    matchFn = matches;\n    argsBuilder = [];\n    attrsBuilder = [];\n    currentNode = null;\n    currentParent = node.parentNode;\n    focusPath = getFocusedPath(node, currentParent);\n\n    if (DEBUG) {\n      previousInAttributes = setInAttributes(false);\n      previousInSkip = setInSkip(false);\n      updatePatchContext(context);\n    }\n\n    try {\n      const retVal = run(node, fn, data);\n      if (DEBUG) {\n        assertVirtualAttributesClosed();\n      }\n\n      return retVal;\n    } finally {\n      context.notifyChanges();\n\n      doc = prevDoc;\n      context = prevContext;\n      matchFn = prevMatchFn;\n      argsBuilder = prevArgsBuilder;\n      attrsBuilder = prevAttrsBuilder;\n      currentNode = prevCurrentNode;\n      currentParent = prevCurrentParent;\n      focusPath = prevFocusPath;\n\n      // Needs to be done after assertions because assertions rely on state\n      // from these methods.\n      if (DEBUG) {\n        setInAttributes(previousInAttributes);\n        setInSkip(previousInSkip);\n        updatePatchContext(context);\n      }\n    }\n  };\n  return f;\n}\n\n/**\n * Creates a patcher that patches the document starting at node with a\n * provided function. This function may be called during an existing patch operation.\n * @param patchConfig The config to use for the patch.\n * @returns The created function for patching an Element's children.\n */\nfunction createPatchInner<T>(\n  patchConfig?: PatchConfig\n): PatchFunction<T, Node> {\n  return createPatcher((node, fn, data) => {\n    currentNode = node;\n\n    enterNode();\n    fn(data);\n    exitNode();\n\n    if (DEBUG) {\n      assertNoUnclosedTags(currentNode, node);\n    }\n\n    return node;\n  }, patchConfig);\n}\n\n/**\n * Creates a patcher that patches an Element with the the provided function.\n * Exactly one top level element call should be made corresponding to `node`.\n * @param patchConfig The config to use for the patch.\n * @returns The created function for patching an Element.\n */\nfunction createPatchOuter<T>(\n  patchConfig?: PatchConfig\n): PatchFunction<T, Node | null> {\n  return createPatcher((node, fn, data) => {\n    const startNode = ({ nextSibling: node } as any) as Element;\n    let expectedNextNode: Node | null = null;\n    let expectedPrevNode: Node | null = null;\n\n    if (DEBUG) {\n      expectedNextNode = node.nextSibling;\n      expectedPrevNode = node.previousSibling;\n    }\n\n    currentNode = startNode;\n    fn(data);\n\n    if (DEBUG) {\n      if (getData(node).key) {\n        assertPatchOuterHasParentNode(currentParent);\n      }\n      assertPatchElementNoExtras(\n        startNode,\n        currentNode,\n        expectedNextNode,\n        expectedPrevNode\n      );\n    }\n\n    if (currentParent) {\n      clearUnvisitedDOM(currentParent, getNextNode(), node.nextSibling);\n    }\n\n    return startNode === currentNode ? null : currentNode;\n  }, patchConfig);\n}\n\nconst patchInner: <T>(\n  node: Element | DocumentFragment,\n  template: (a: T | undefined) => void,\n  data?: T | undefined\n) => Node = createPatchInner();\nconst patchOuter: <T>(\n  node: Element | DocumentFragment,\n  template: (a: T | undefined) => void,\n  data?: T | undefined\n) => Node | null = createPatchOuter();\n\nexport {\n  alignWithDOM,\n  alwaysDiffAttributes,\n  getArgsBuilder,\n  getAttrsBuilder,\n  text,\n  createPatchInner,\n  createPatchOuter,\n  patchInner,\n  patchOuter,\n  open,\n  close,\n  currentElement,\n  currentContext,\n  currentPointer,\n  skip,\n  nextNode as skipNode,\n  tryGetCurrentElement\n};\n"]} \ No newline at end of file diff --git a/closure/src/debug.d.ts b/closure/src/debug.d.ts new file mode 100755 index 00000000..5902e6db --- /dev/null +++ b/closure/src/debug.d.ts @@ -0,0 +1,2 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +export declare const DEBUG = true; diff --git a/closure/src/debug.js b/closure/src/debug.js new file mode 100755 index 00000000..7da605d3 --- /dev/null +++ b/closure/src/debug.js @@ -0,0 +1,13 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/debug.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +goog.module('incrementaldom.src.debug'); +var module = module || { id: 'src/debug.js' }; +goog.require('tslib'); +/** @type {boolean} */ +exports.DEBUG = true; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVidWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGVidWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7QUFHYSxRQUFBLEtBQUssR0FBRyxJQUFJIiwic291cmNlc0NvbnRlbnQiOlsiLy8gIENvcHlyaWdodCAyMDE4IFRoZSBJbmNyZW1lbnRhbCBET00gQXV0aG9ycy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbi8qKiBAbGljZW5zZSBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMCAqL1xuXG5leHBvcnQgY29uc3QgREVCVUcgPSB0cnVlO1xuIl19 \ No newline at end of file diff --git a/closure/src/diff.d.ts b/closure/src/diff.d.ts new file mode 100755 index 00000000..3fb00309 --- /dev/null +++ b/closure/src/diff.d.ts @@ -0,0 +1,16 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +import { AttrMutatorConfig } from "./types"; +/** + * Calculates the diff between previous and next values, calling the update + * function when an item has changed value. If an item from the previous values + * is not present in the the next values, the update function is called with a + * value of `undefined`. + * @param prev The previous values, alternating name, value pairs. + * @param next The next values, alternating name, value pairs. + * @param updateCtx The context for the updateFn. + * @param updateFn A function to call when a value has changed. + * @param attrs Attribute map for mutators + * @param alwaysDiffAttributes Whether to diff attributes unconditionally + */ +declare function calculateDiff(prev: Array, next: Array, updateCtx: T, updateFn: (ctx: T, x: string, y: {} | undefined, attrs: AttrMutatorConfig) => void, attrs: AttrMutatorConfig, alwaysDiffAttributes?: boolean): void; +export { calculateDiff }; diff --git a/closure/src/diff.js b/closure/src/diff.js new file mode 100755 index 00000000..11e55854 --- /dev/null +++ b/closure/src/diff.js @@ -0,0 +1,86 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/diff.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +goog.module('incrementaldom.src.diff'); +var module = module || { id: 'src/diff.js' }; +goog.require('tslib'); +const tsickle_types_1 = goog.requireType("incrementaldom.src.types"); +const tsickle_util_2 = goog.requireType("incrementaldom.src.util"); +const tsickle_changes_3 = goog.requireType("incrementaldom.src.changes"); +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +var util_1 = goog.require('incrementaldom.src.util'); +var changes_1 = goog.require('incrementaldom.src.changes'); +/** + * Used to keep track of the previous values when a 2-way diff is necessary. + * This object is cleared out and reused. + * @type {?} + */ +const prevValuesMap = util_1.createMap(); +/** + * Calculates the diff between previous and next values, calling the update + * function when an item has changed value. If an item from the previous values + * is not present in the the next values, the update function is called with a + * value of `undefined`. + * @template T + * @param {!Array} prev The previous values, alternating name, value pairs. + * @param {!Array} next The next values, alternating name, value pairs. + * @param {T} updateCtx The context for the updateFn. + * @param {function(T, string, (undefined|*), !tsickle_types_1.AttrMutatorConfig): void} updateFn A function to call when a value has changed. + * @param {!tsickle_types_1.AttrMutatorConfig} attrs Attribute map for mutators + * @param {boolean=} alwaysDiffAttributes Whether to diff attributes unconditionally + * @return {void} + */ +function calculateDiff(prev, next, updateCtx, updateFn, attrs, alwaysDiffAttributes = false) { + /** @type {boolean} */ + const isNew = !prev.length || alwaysDiffAttributes; + /** @type {number} */ + let i = 0; + for (; i < next.length; i += 2) { + /** @type {string} */ + const name = next[i]; + if (isNew) { + prev[i] = name; + } + else if (prev[i] !== name) { + break; + } + /** @type {string} */ + const value = next[i + 1]; + if (isNew || prev[i + 1] !== value) { + prev[i + 1] = value; + changes_1.queueChange(updateFn, updateCtx, name, value, attrs); + } + } + // Items did not line up exactly as before, need to make sure old items are + // removed. This should be a rare case. + if (i < next.length || i < prev.length) { + /** @type {number} */ + const startIndex = i; + for (i = startIndex; i < prev.length; i += 2) { + prevValuesMap[prev[i]] = prev[i + 1]; + } + for (i = startIndex; i < next.length; i += 2) { + /** @type {string} */ + const name = (/** @type {string} */ (next[i])); + /** @type {string} */ + const value = next[i + 1]; + if (prevValuesMap[name] !== value) { + changes_1.queueChange(updateFn, updateCtx, name, value, attrs); + } + prev[i] = name; + prev[i + 1] = value; + delete prevValuesMap[name]; + } + util_1.truncateArray(prev, next.length); + for (const name in prevValuesMap) { + changes_1.queueChange(updateFn, updateCtx, name, undefined, attrs); + delete prevValuesMap[name]; + } + } + changes_1.flush(); +} +exports.calculateDiff = calculateDiff; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/closure/src/dom_util.d.ts b/closure/src/dom_util.d.ts new file mode 100755 index 00000000..daa381c3 --- /dev/null +++ b/closure/src/dom_util.d.ts @@ -0,0 +1,30 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +/** + * Checks if the node is an Element. This is faster than an instanceof check. + * @param node The node to check. + * @return Whether or not the node is an Element. + */ +declare function isElement(node: Node): node is Element; +/** + * Checks if the node is a text node. This is faster than an instanceof check. + * @param node The node to check. + * @return Whether or not the node is a Text. + */ +declare function isText(node: Node): node is Text; +/** + * Gets the path of nodes that contain the focused node in the same document as + * a reference node, up until the root. + * @param node The reference node to get the activeElement for. + * @param root The root to get the focused path until. + * @returns The path of focused parents, if any exist. + */ +declare function getFocusedPath(node: Node, root: Node | null): Array; +/** + * Like insertBefore, but instead of moving the desired node, it moves all the + * other nodes after. + * @param parentNode + * @param node + * @param referenceNode + */ +declare function moveBefore(parentNode: Node, node: Node, referenceNode: Node | null): void; +export { isElement, isText, getFocusedPath, moveBefore }; diff --git a/closure/src/dom_util.js b/closure/src/dom_util.js new file mode 100755 index 00000000..2427c58c --- /dev/null +++ b/closure/src/dom_util.js @@ -0,0 +1,127 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/dom_util.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +goog.module('incrementaldom.src.dom_util'); +var module = module || { id: 'src/dom_util.js' }; +goog.require('tslib'); +const tsickle_assertions_1 = goog.requireType("incrementaldom.src.assertions"); +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +var assertions_1 = goog.require('incrementaldom.src.assertions'); +/** + * Checks if the node is the root of a document. This is either a Document + * or ShadowRoot. DocumentFragments are included for simplicity of the + * implementation, though we only want to consider Documents or ShadowRoots. + * @param {!Node} node The node to check. + * @return {boolean} True if the node the root of a document, false otherwise. + */ +function isDocumentRoot(node) { + return node.nodeType === 11 || node.nodeType === 9; +} +/** + * Checks if the node is an Element. This is faster than an instanceof check. + * @param {!Node} node The node to check. + * @return {boolean} Whether or not the node is an Element. + */ +function isElement(node) { + return node.nodeType === 1; +} +exports.isElement = isElement; +/** + * Checks if the node is a text node. This is faster than an instanceof check. + * @param {!Node} node The node to check. + * @return {boolean} Whether or not the node is a Text. + */ +function isText(node) { + return node.nodeType === 3; +} +exports.isText = isText; +/** + * @param {!Node} node The node to start at, inclusive. + * @param {(null|!Node)} root The root ancestor to get until, exclusive. + * @return {!Array} The ancestry of DOM nodes. + */ +function getAncestry(node, root) { + /** @type {!Array} */ + const ancestry = []; + /** @type {(null|!Node)} */ + let cur = node; + while (cur !== root) { + /** @type {!Node} */ + const n = assertions_1.assert(cur); + ancestry.push(n); + cur = n.parentNode; + } + return ancestry; +} +/** + * \@param this + * \@return The root node of the DOM tree that contains this node. + * @type {?} + */ +const getRootNode = (typeof Node !== "undefined" && ((/** @type {?} */ (Node))).prototype.getRootNode) || + (/** + * @this {!Node} + * @return {!Node} + */ + function () { + /** @type {(null|!Node)} */ + let cur = (/** @type {!Node} */ (this)); + /** @type {!Node} */ + let prev = cur; + while (cur) { + prev = cur; + cur = cur.parentNode; + } + return prev; + }); +/** + * @param {!Node} node The node to get the activeElement for. + * @return {(null|!Element)} The activeElement in the Document or ShadowRoot + * corresponding to node, if present. + */ +function getActiveElement(node) { + /** @type {?} */ + const root = getRootNode.call(node); + return isDocumentRoot(root) ? root.activeElement : null; +} +/** + * Gets the path of nodes that contain the focused node in the same document as + * a reference node, up until the root. + * @param {!Node} node The reference node to get the activeElement for. + * @param {(null|!Node)} root The root to get the focused path until. + * @return {!Array} The path of focused parents, if any exist. + */ +function getFocusedPath(node, root) { + /** @type {(null|!Element)} */ + const activeElement = getActiveElement(node); + if (!activeElement || !node.contains(activeElement)) { + return []; + } + return getAncestry(activeElement, root); +} +exports.getFocusedPath = getFocusedPath; +/** + * Like insertBefore, but instead of moving the desired node, it moves all the + * other nodes after. + * @param {!Node} parentNode + * @param {!Node} node + * @param {(null|!Node)} referenceNode + * @return {void} + */ +function moveBefore(parentNode, node, referenceNode) { + /** @type {(null|!ChildNode)} */ + const insertReferenceNode = node.nextSibling; + /** @type {(null|!Node)} */ + let cur = referenceNode; + while (cur !== null && cur !== node) { + /** @type {(null|!ChildNode)} */ + const next = cur.nextSibling; + parentNode.insertBefore(cur, insertReferenceNode); + cur = next; + } +} +exports.moveBefore = moveBefore; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/closure/src/global.d.ts b/closure/src/global.d.ts new file mode 100755 index 00000000..2183066c --- /dev/null +++ b/closure/src/global.d.ts @@ -0,0 +1,5 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +declare function getKeyAttributeName(): string | null; +declare function setKeyAttributeName(name: string | null): void; +export { DEBUG } from "./debug"; +export { getKeyAttributeName, setKeyAttributeName }; diff --git a/closure/src/global.js b/closure/src/global.js new file mode 100755 index 00000000..2605e411 --- /dev/null +++ b/closure/src/global.js @@ -0,0 +1,37 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/global.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +goog.module('incrementaldom.src.global'); +var module = module || { id: 'src/global.js' }; +goog.require('tslib'); +const tsickle_debug_1 = goog.requireType("incrementaldom.src.debug"); +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +/** + * The name of the HTML attribute that holds the element key + * (e.g. `
`). The attribute value, if it exists, is then used + * as the default key when importing an element. + * If null, no attribute value is used as the default key. + * @type {(null|string)} + */ +let keyAttributeName = "key"; +/** + * @return {(null|string)} + */ +function getKeyAttributeName() { + return keyAttributeName; +} +exports.getKeyAttributeName = getKeyAttributeName; +/** + * @param {(null|string)} name + * @return {void} + */ +function setKeyAttributeName(name) { + keyAttributeName = name; +} +exports.setKeyAttributeName = setKeyAttributeName; +var debug_1 = goog.require('incrementaldom.src.debug'); +exports.DEBUG = debug_1.DEBUG; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2xvYmFsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2dsb2JhbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7SUFTSSxnQkFBZ0IsR0FBa0IsS0FBSzs7OztBQUUzQyxTQUFTLG1CQUFtQjtJQUMxQixPQUFPLGdCQUFnQixDQUFDO0FBQzFCLENBQUM7QUFPUSxrREFBbUI7Ozs7O0FBTDVCLFNBQVMsbUJBQW1CLENBQUMsSUFBbUI7SUFDOUMsZ0JBQWdCLEdBQUcsSUFBSSxDQUFDO0FBQzFCLENBQUM7QUFHNkIsa0RBQW1CO0FBRGpELHdEQUFnQztBQUF2Qix3QkFBQSxLQUFLLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyIvLyAgQ29weXJpZ2h0IDIwMTggVGhlIEluY3JlbWVudGFsIERPTSBBdXRob3JzLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuLyoqIEBsaWNlbnNlIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wICovXG5cbi8qKlxuICogVGhlIG5hbWUgb2YgdGhlIEhUTUwgYXR0cmlidXRlIHRoYXQgaG9sZHMgdGhlIGVsZW1lbnQga2V5XG4gKiAoZS5nLiBgPGRpdiBrZXk9XCJmb29cIj5gKS4gVGhlIGF0dHJpYnV0ZSB2YWx1ZSwgaWYgaXQgZXhpc3RzLCBpcyB0aGVuIHVzZWRcbiAqIGFzIHRoZSBkZWZhdWx0IGtleSB3aGVuIGltcG9ydGluZyBhbiBlbGVtZW50LlxuICogSWYgbnVsbCwgbm8gYXR0cmlidXRlIHZhbHVlIGlzIHVzZWQgYXMgdGhlIGRlZmF1bHQga2V5LlxuICovXG5sZXQga2V5QXR0cmlidXRlTmFtZTogc3RyaW5nIHwgbnVsbCA9IFwia2V5XCI7XG5cbmZ1bmN0aW9uIGdldEtleUF0dHJpYnV0ZU5hbWUoKSB7XG4gIHJldHVybiBrZXlBdHRyaWJ1dGVOYW1lO1xufVxuXG5mdW5jdGlvbiBzZXRLZXlBdHRyaWJ1dGVOYW1lKG5hbWU6IHN0cmluZyB8IG51bGwpIHtcbiAga2V5QXR0cmlidXRlTmFtZSA9IG5hbWU7XG59XG5cbmV4cG9ydCB7IERFQlVHIH0gZnJvbSBcIi4vZGVidWdcIjtcbmV4cG9ydCB7IGdldEtleUF0dHJpYnV0ZU5hbWUsIHNldEtleUF0dHJpYnV0ZU5hbWUgfTtcbiJdfQ== \ No newline at end of file diff --git a/closure/src/node_data.d.ts b/closure/src/node_data.d.ts new file mode 100755 index 00000000..4cf91eb3 --- /dev/null +++ b/closure/src/node_data.d.ts @@ -0,0 +1,80 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +import { Key, NameOrCtorDef } from "./types"; +declare global { + interface Node { + __incrementalDOMData: NodeData | null; + } +} +/** + * Keeps track of information needed to perform diffs for a given DOM node. + */ +export declare class NodeData { + /** + * An array of attribute name/value pairs, used for quickly diffing the + * incomming attributes to see if the DOM node's attributes need to be + * updated. + */ + private _attrsArr; + /** + * Whether or not the statics have been applied for the node yet. + */ + staticsApplied: boolean; + /** + * The key used to identify this node, used to preserve DOM nodes when they + * move within their parent. + */ + readonly key: Key; + /** + * The previous text value, for Text nodes. + */ + text: string | undefined; + /** + * The nodeName or contructor for the Node. + */ + readonly nameOrCtor: NameOrCtorDef; + alwaysDiffAttributes: boolean; + constructor(nameOrCtor: NameOrCtorDef, key: Key, text: string | undefined); + hasEmptyAttrsArr(): boolean; + getAttrsArr(length: number): Array; +} +/** + * Initializes a NodeData object for a Node. + * @param node The Node to initialized data for. + * @param nameOrCtor The NameOrCtorDef to use when diffing. + * @param key The Key for the Node. + * @param text The data of a Text node, if importing a Text node. + * @returns A NodeData object with the existing attributes initialized. + */ +declare function initData(node: Node, nameOrCtor: NameOrCtorDef, key: Key, text?: string | undefined): NodeData; +/** + * @param node The node to check. + * @returns True if the NodeData already exists, false otherwise. + */ +declare function isDataInitialized(node: Node): boolean; +/** + * Imports node and its subtree, initializing caches. + * @param node The Node to import. + */ +declare function importNode(node: Node): void; +/** + * Retrieves the NodeData object for a Node, creating it if necessary. + * @param node The node to get data for. + * @param fallbackKey A key to use if importing and no key was specified. + * Useful when not transmitting keys from serverside render and doing an + * immediate no-op diff. + * @returns The NodeData for the node. + */ +declare function getData(node: Node, fallbackKey?: Key): NodeData; +/** + * Gets the key for a Node. note that the Node should have been imported + * by now. + * @param node The node to check. + * @returns The key used to create the node. + */ +declare function getKey(node: Node): Key; +/** + * Clears all caches from a node and all of its children. + * @param node The Node to clear the cache for. + */ +declare function clearCache(node: Node): void; +export { getData, getKey, initData, importNode, isDataInitialized, clearCache }; diff --git a/closure/src/node_data.js b/closure/src/node_data.js new file mode 100755 index 00000000..74c76ede --- /dev/null +++ b/closure/src/node_data.js @@ -0,0 +1,226 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/node_data.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +goog.module('incrementaldom.src.node_data'); +var module = module || { id: 'src/node_data.js' }; +goog.require('tslib'); +const tsickle_types_1 = goog.requireType("incrementaldom.src.types"); +const tsickle_assertions_2 = goog.requireType("incrementaldom.src.assertions"); +const tsickle_util_3 = goog.requireType("incrementaldom.src.util"); +const tsickle_dom_util_4 = goog.requireType("incrementaldom.src.dom_util"); +const tsickle_global_5 = goog.requireType("incrementaldom.src.global"); +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +var assertions_1 = goog.require('incrementaldom.src.assertions'); +var util_1 = goog.require('incrementaldom.src.util'); +var dom_util_1 = goog.require('incrementaldom.src.dom_util'); +var global_1 = goog.require('incrementaldom.src.global'); +/** + * Keeps track of information needed to perform diffs for a given DOM node. + */ +class NodeData { + /** + * @param {(string|!tsickle_types_1.ElementConstructor)} nameOrCtor + * @param {(undefined|null|string|number)} key + * @param {(undefined|string)} text + */ + constructor(nameOrCtor, key, text) { + /** + * An array of attribute name/value pairs, used for quickly diffing the + * incomming attributes to see if the DOM node's attributes need to be + * updated. + */ + this._attrsArr = null; + /** + * Whether or not the statics have been applied for the node yet. + */ + this.staticsApplied = false; + this.alwaysDiffAttributes = false; + this.nameOrCtor = nameOrCtor; + this.key = key; + this.text = text; + } + /** + * @return {boolean} + */ + hasEmptyAttrsArr() { + /** @type {(null|!Array)} */ + const attrs = this._attrsArr; + return !attrs || !attrs.length; + } + /** + * @param {number} length + * @return {!Array} + */ + getAttrsArr(length) { + return this._attrsArr || (this._attrsArr = util_1.createArray(length)); + } +} +exports.NodeData = NodeData; +/* istanbul ignore if */ +if (false) { + /** + * An array of attribute name/value pairs, used for quickly diffing the + * incomming attributes to see if the DOM node's attributes need to be + * updated. + * @type {(null|!Array)} + * @private + */ + NodeData.prototype._attrsArr; + /** + * Whether or not the statics have been applied for the node yet. + * @type {boolean} + */ + NodeData.prototype.staticsApplied; + /** + * The key used to identify this node, used to preserve DOM nodes when they + * move within their parent. + * @type {(undefined|null|string|number)} + */ + NodeData.prototype.key; + /** + * The previous text value, for Text nodes. + * @type {(undefined|string)} + */ + NodeData.prototype.text; + /** + * The nodeName or contructor for the Node. + * @type {(string|!tsickle_types_1.ElementConstructor)} + */ + NodeData.prototype.nameOrCtor; + /** @type {boolean} */ + NodeData.prototype.alwaysDiffAttributes; +} +/** + * Initializes a NodeData object for a Node. + * @param {!Node} node The Node to initialized data for. + * @param {(string|!tsickle_types_1.ElementConstructor)} nameOrCtor The NameOrCtorDef to use when diffing. + * @param {(undefined|null|string|number)} key The Key for the Node. + * @param {(undefined|string)=} text The data of a Text node, if importing a Text node. + * @return {!NodeData} A NodeData object with the existing attributes initialized. + */ +function initData(node, nameOrCtor, key, text) { + /** @type {!NodeData} */ + const data = new NodeData(nameOrCtor, key, text); + node["__incrementalDOMData"] = data; + return data; +} +exports.initData = initData; +/** + * @param {!Node} node The node to check. + * @return {boolean} True if the NodeData already exists, false otherwise. + */ +function isDataInitialized(node) { + return Boolean(node["__incrementalDOMData"]); +} +exports.isDataInitialized = isDataInitialized; +/** + * Records the element's attributes. + * @param {!Element} node The Element that may have attributes + * @param {!NodeData} data The Element's data + * @return {void} + */ +function recordAttributes(node, data) { + /** @type {!NamedNodeMap} */ + const attributes = node.attributes; + /** @type {number} */ + const length = attributes.length; + if (!length) { + return; + } + /** @type {!Array} */ + const attrsArr = data.getAttrsArr(length); + // Use a cached length. The attributes array is really a live NamedNodeMap, + // which exists as a DOM "Host Object" (probably as C++ code). This makes the + // usual constant length iteration very difficult to optimize in JITs. + for (let i = 0, j = 0; i < length; i += 1, j += 2) { + /** @type {!Attr} */ + const attr = attributes[i]; + /** @type {string} */ + const name = attr.name; + /** @type {string} */ + const value = attr.value; + attrsArr[j] = name; + attrsArr[j + 1] = value; + } +} +/** + * Imports single node and its subtree, initializing caches, if it has not + * already been imported. + * @param {!Node} node The node to import. + * @param {(undefined|null|string|number)=} fallbackKey A key to use if importing and no key was specified. + * Useful when not transmitting keys from serverside render and doing an + * immediate no-op diff. + * @return {!NodeData} The NodeData for the node. + */ +function importSingleNode(node, fallbackKey) { + if (node["__incrementalDOMData"]) { + return node["__incrementalDOMData"]; + } + /** @type {string} */ + const nodeName = dom_util_1.isElement(node) ? node.localName : node.nodeName; + /** @type {(null|string)} */ + const keyAttrName = global_1.getKeyAttributeName(); + /** @type {(null|string)} */ + const keyAttr = dom_util_1.isElement(node) && keyAttrName != null + ? node.getAttribute(keyAttrName) + : null; + /** @type {(undefined|null|string|number)} */ + const key = dom_util_1.isElement(node) ? keyAttr || fallbackKey : null; + /** @type {!NodeData} */ + const data = initData(node, nodeName, key); + if (dom_util_1.isElement(node)) { + recordAttributes(node, data); + } + return data; +} +/** + * Imports node and its subtree, initializing caches. + * @param {!Node} node The Node to import. + * @return {void} + */ +function importNode(node) { + importSingleNode(node); + for (let child = node.firstChild; child; child = child.nextSibling) { + importNode(child); + } +} +exports.importNode = importNode; +/** + * Retrieves the NodeData object for a Node, creating it if necessary. + * @param {!Node} node The node to get data for. + * @param {(undefined|null|string|number)=} fallbackKey A key to use if importing and no key was specified. + * Useful when not transmitting keys from serverside render and doing an + * immediate no-op diff. + * @return {!NodeData} The NodeData for the node. + */ +function getData(node, fallbackKey) { + return importSingleNode(node, fallbackKey); +} +exports.getData = getData; +/** + * Gets the key for a Node. note that the Node should have been imported + * by now. + * @param {!Node} node The node to check. + * @return {(undefined|null|string|number)} The key used to create the node. + */ +function getKey(node) { + assertions_1.assert(node["__incrementalDOMData"]); + return getData(node).key; +} +exports.getKey = getKey; +/** + * Clears all caches from a node and all of its children. + * @param {!Node} node The Node to clear the cache for. + * @return {void} + */ +function clearCache(node) { + node["__incrementalDOMData"] = null; + for (let child = node.firstChild; child; child = child.nextSibling) { + clearCache(child); + } +} +exports.clearCache = clearCache; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node_data.js","sourceRoot":"","sources":["../../../../src/node_data.ts"],"names":[],"mappings":"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","sourcesContent":["//  Copyright 2018 The Incremental DOM Authors. All Rights Reserved.\n/** @license SPDX-License-Identifier: Apache-2.0 */\n\nimport { Key, NameOrCtorDef } from \"./types\";\nimport { assert } from \"./assertions\";\nimport { createArray } from \"./util\";\nimport { isElement } from \"./dom_util\";\nimport { getKeyAttributeName } from \"./global\";\n\ndeclare global {\n  interface Node {\n    __incrementalDOMData: NodeData | null;\n  }\n}\n\n/**\n * Keeps track of information needed to perform diffs for a given DOM node.\n */\nexport class NodeData {\n  /**\n   * An array of attribute name/value pairs, used for quickly diffing the\n   * incomming attributes to see if the DOM node's attributes need to be\n   * updated.\n   */\n  private _attrsArr: Array<any> | null = null;\n\n  /**\n   * Whether or not the statics have been applied for the node yet.\n   */\n  public staticsApplied = false;\n\n  /**\n   * The key used to identify this node, used to preserve DOM nodes when they\n   * move within their parent.\n   */\n  public readonly key: Key;\n\n  /**\n   * The previous text value, for Text nodes.\n   */\n  public text: string | undefined;\n\n  /**\n   * The nodeName or contructor for the Node.\n   */\n  public readonly nameOrCtor: NameOrCtorDef;\n\n  public alwaysDiffAttributes = false;\n\n  public constructor(\n    nameOrCtor: NameOrCtorDef,\n    key: Key,\n    text: string | undefined\n  ) {\n    this.nameOrCtor = nameOrCtor;\n    this.key = key;\n    this.text = text;\n  }\n\n  public hasEmptyAttrsArr(): boolean {\n    const attrs = this._attrsArr;\n    return !attrs || !attrs.length;\n  }\n\n  public getAttrsArr(length: number): Array<any> {\n    return this._attrsArr || (this._attrsArr = createArray(length));\n  }\n}\n\n/**\n * Initializes a NodeData object for a Node.\n * @param node The Node to initialized data for.\n * @param nameOrCtor The NameOrCtorDef to use when diffing.\n * @param key The Key for the Node.\n * @param text The data of a Text node, if importing a Text node.\n * @returns A NodeData object with the existing attributes initialized.\n */\nfunction initData(\n  node: Node,\n  nameOrCtor: NameOrCtorDef,\n  key: Key,\n  text?: string | undefined\n): NodeData {\n  const data = new NodeData(nameOrCtor, key, text);\n  node[\"__incrementalDOMData\"] = data;\n  return data;\n}\n\n/**\n * @param node The node to check.\n * @returns True if the NodeData already exists, false otherwise.\n */\nfunction isDataInitialized(node: Node): boolean {\n  return Boolean(node[\"__incrementalDOMData\"]);\n}\n\n/**\n * Records the element's attributes.\n * @param node The Element that may have attributes\n * @param data The Element's data\n */\nfunction recordAttributes(node: Element, data: NodeData) {\n  const attributes = node.attributes;\n  const length = attributes.length;\n  if (!length) {\n    return;\n  }\n\n  const attrsArr = data.getAttrsArr(length);\n\n  // Use a cached length. The attributes array is really a live NamedNodeMap,\n  // which exists as a DOM \"Host Object\" (probably as C++ code). This makes the\n  // usual constant length iteration very difficult to optimize in JITs.\n  for (let i = 0, j = 0; i < length; i += 1, j += 2) {\n    const attr = attributes[i];\n    const name = attr.name;\n    const value = attr.value;\n\n    attrsArr[j] = name;\n    attrsArr[j + 1] = value;\n  }\n}\n\n/**\n * Imports single node and its subtree, initializing caches, if it has not\n * already been imported.\n * @param node The node to import.\n * @param fallbackKey A key to use if importing and no key was specified.\n *    Useful when not transmitting keys from serverside render and doing an\n *    immediate no-op diff.\n * @returns The NodeData for the node.\n */\nfunction importSingleNode(node: Node, fallbackKey?: Key): NodeData {\n  if (node[\"__incrementalDOMData\"]) {\n    return node[\"__incrementalDOMData\"];\n  }\n\n  const nodeName = isElement(node) ? node.localName : node.nodeName;\n  const keyAttrName = getKeyAttributeName();\n  const keyAttr =\n    isElement(node) && keyAttrName != null\n      ? node.getAttribute(keyAttrName)\n      : null;\n  const key = isElement(node) ? keyAttr || fallbackKey : null;\n  const data = initData(node, nodeName, key);\n\n  if (isElement(node)) {\n    recordAttributes(node, data);\n  }\n\n  return data;\n}\n\n/**\n * Imports node and its subtree, initializing caches.\n * @param node The Node to import.\n */\nfunction importNode(node: Node) {\n  importSingleNode(node);\n\n  for (\n    let child: Node | null = node.firstChild;\n    child;\n    child = child.nextSibling\n  ) {\n    importNode(child);\n  }\n}\n\n/**\n * Retrieves the NodeData object for a Node, creating it if necessary.\n * @param node The node to get data for.\n * @param fallbackKey A key to use if importing and no key was specified.\n *    Useful when not transmitting keys from serverside render and doing an\n *    immediate no-op diff.\n * @returns The NodeData for the node.\n */\nfunction getData(node: Node, fallbackKey?: Key) {\n  return importSingleNode(node, fallbackKey);\n}\n\n/**\n * Gets the key for a Node. note that the Node should have been imported\n * by now.\n * @param node The node to check.\n * @returns The key used to create the node.\n */\nfunction getKey(node: Node) {\n  assert(node[\"__incrementalDOMData\"]);\n  return getData(node).key;\n}\n\n/**\n * Clears all caches from a node and all of its children.\n * @param node The Node to clear the cache for.\n */\nfunction clearCache(node: Node) {\n  node[\"__incrementalDOMData\"] = null;\n\n  for (\n    let child: Node | null = node.firstChild;\n    child;\n    child = child.nextSibling\n  ) {\n    clearCache(child);\n  }\n}\n\nexport { getData, getKey, initData, importNode, isDataInitialized, clearCache };\n"]} \ No newline at end of file diff --git a/closure/src/nodes.d.ts b/closure/src/nodes.d.ts new file mode 100755 index 00000000..0d5de052 --- /dev/null +++ b/closure/src/nodes.d.ts @@ -0,0 +1,18 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +import { Key, NameOrCtorDef } from "./types"; +/** + * Creates an Element and initializes the NodeData. + * @param doc The document with which to create the Element. + * @param parent The parent of new Element. + * @param nameOrCtor The tag or constructor for the Element. + * @param key A key to identify the Element. + * @returns The newly created Element. + */ +declare function createElement(doc: Document, parent: Node | null, nameOrCtor: NameOrCtorDef, key: Key): Element; +/** + * Creates a Text Node. + * @param doc The document with which to create the Element. + * @returns The newly created Text. + */ +declare function createText(doc: Document): Text; +export { createElement, createText }; diff --git a/closure/src/nodes.js b/closure/src/nodes.js new file mode 100755 index 00000000..42ff8726 --- /dev/null +++ b/closure/src/nodes.js @@ -0,0 +1,80 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/nodes.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +goog.module('incrementaldom.src.nodes'); +var module = module || { id: 'src/nodes.js' }; +goog.require('tslib'); +const tsickle_node_data_1 = goog.requireType("incrementaldom.src.node_data"); +const tsickle_types_2 = goog.requireType("incrementaldom.src.types"); +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +var node_data_1 = goog.require('incrementaldom.src.node_data'); +/** + * Gets the namespace to create an element (of a given tag) in. + * @param {string} tag The tag to get the namespace for. + * @param {(null|!Node)} parent The current parent Node, if any. + * @return {?} The namespace to use. + */ +function getNamespaceForTag(tag, parent) { + if (tag === "svg") { + return "http://www.w3.org/2000/svg"; + } + if (tag === "math") { + return "http://www.w3.org/1998/Math/MathML"; + } + if (parent == null) { + return null; + } + if (node_data_1.getData(parent).nameOrCtor === "foreignObject") { + return null; + } + // Since TypeScript 4.4 namespaceURI is only defined for Attr and Element + // nodes. Checking for Element nodes here seems reasonable but breaks SVG + // rendering in Chrome in certain cases. The cast to any should be removed + // once we know why this happens. + // eslint-disable-next-line @typescript-eslint/no-explicit-any + return ((/** @type {?} */ (parent))).namespaceURI; +} +/** + * Creates an Element and initializes the NodeData. + * @param {!Document} doc The document with which to create the Element. + * @param {(null|!Node)} parent The parent of new Element. + * @param {(string|!tsickle_types_2.ElementConstructor)} nameOrCtor The tag or constructor for the Element. + * @param {(undefined|null|string|number)} key A key to identify the Element. + * @return {!Element} The newly created Element. + */ +function createElement(doc, parent, nameOrCtor, key) { + /** @type {?} */ + let el; + if (typeof nameOrCtor === "function") { + el = new nameOrCtor(); + } + else { + /** @type {?} */ + const namespace = getNamespaceForTag(nameOrCtor, parent); + if (namespace) { + el = doc.createElementNS(namespace, nameOrCtor); + } + else { + el = doc.createElement(nameOrCtor); + } + } + node_data_1.initData(el, nameOrCtor, key); + return el; +} +exports.createElement = createElement; +/** + * Creates a Text Node. + * @param {!Document} doc The document with which to create the Element. + * @return {!Text} The newly created Text. + */ +function createText(doc) { + /** @type {!Text} */ + const node = doc.createTextNode(""); + node_data_1.initData(node, "#text", null); + return node; +} +exports.createText = createText; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/closure/src/notifications.d.ts b/closure/src/notifications.d.ts new file mode 100755 index 00000000..9ef4ae2c --- /dev/null +++ b/closure/src/notifications.d.ts @@ -0,0 +1,16 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +export declare type NodeFunction = (n: Array) => void; +export interface Notifications { + /** + * Called after patch has completed with any Nodes that have been created + * and added to the DOM. + */ + nodesCreated: NodeFunction | null; + /** + * Called after patch has completed with any Nodes that have been removed + * from the DOM. + * Note it's an application's responsibility to handle any childNodes. + */ + nodesDeleted: NodeFunction | null; +} +export declare const notifications: Notifications; diff --git a/closure/src/notifications.js b/closure/src/notifications.js new file mode 100755 index 00000000..8a3068c1 --- /dev/null +++ b/closure/src/notifications.js @@ -0,0 +1,39 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/notifications.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +goog.module('incrementaldom.src.notifications'); +var module = module || { id: 'src/notifications.js' }; +goog.require('tslib'); +/** @typedef {function(!Array): void} */ +exports.NodeFunction; +/** + * @record + */ +function Notifications() { } +exports.Notifications = Notifications; +/* istanbul ignore if */ +if (false) { + /** + * Called after patch has completed with any Nodes that have been created + * and added to the DOM. + * @type {(null|function(!Array): void)} + */ + Notifications.prototype.nodesCreated; + /** + * Called after patch has completed with any Nodes that have been removed + * from the DOM. + * Note it's an application's responsibility to handle any childNodes. + * @type {(null|function(!Array): void)} + */ + Notifications.prototype.nodesDeleted; +} +/** @type {!Notifications} */ +exports.notifications = { + nodesCreated: null, + nodesDeleted: null +}; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9ub3RpZmljYXRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7O0FBR0EscUJBQW9EOzs7O0FBRXBELDRCQVlDOzs7Ozs7Ozs7SUFQQyxxQ0FBa0M7Ozs7Ozs7SUFNbEMscUNBQWtDOzs7QUFHdkIsUUFBQSxhQUFhLEdBQWtCO0lBQzFDLFlBQVksRUFBRSxJQUFJO0lBQ2xCLFlBQVksRUFBRSxJQUFJO0NBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiLy8gIENvcHlyaWdodCAyMDE4IFRoZSBJbmNyZW1lbnRhbCBET00gQXV0aG9ycy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbi8qKiBAbGljZW5zZSBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMCAqL1xuXG5leHBvcnQgdHlwZSBOb2RlRnVuY3Rpb24gPSAobjogQXJyYXk8Tm9kZT4pID0+IHZvaWQ7XG5cbmV4cG9ydCBpbnRlcmZhY2UgTm90aWZpY2F0aW9ucyB7XG4gIC8qKlxuICAgKiBDYWxsZWQgYWZ0ZXIgcGF0Y2ggaGFzIGNvbXBsZXRlZCB3aXRoIGFueSBOb2RlcyB0aGF0IGhhdmUgYmVlbiBjcmVhdGVkXG4gICAqIGFuZCBhZGRlZCB0byB0aGUgRE9NLlxuICAgKi9cbiAgbm9kZXNDcmVhdGVkOiBOb2RlRnVuY3Rpb24gfCBudWxsO1xuICAvKipcbiAgICogQ2FsbGVkIGFmdGVyIHBhdGNoIGhhcyBjb21wbGV0ZWQgd2l0aCBhbnkgTm9kZXMgdGhhdCBoYXZlIGJlZW4gcmVtb3ZlZFxuICAgKiBmcm9tIHRoZSBET00uXG4gICAqIE5vdGUgaXQncyBhbiBhcHBsaWNhdGlvbidzIHJlc3BvbnNpYmlsaXR5IHRvIGhhbmRsZSBhbnkgY2hpbGROb2Rlcy5cbiAgICovXG4gIG5vZGVzRGVsZXRlZDogTm9kZUZ1bmN0aW9uIHwgbnVsbDtcbn1cblxuZXhwb3J0IGNvbnN0IG5vdGlmaWNhdGlvbnM6IE5vdGlmaWNhdGlvbnMgPSB7XG4gIG5vZGVzQ3JlYXRlZDogbnVsbCxcbiAgbm9kZXNEZWxldGVkOiBudWxsXG59O1xuIl19 \ No newline at end of file diff --git a/closure/src/src_es5_tsconfig.json b/closure/src/src_es5_tsconfig.json new file mode 100755 index 00000000..090daa3f --- /dev/null +++ b/closure/src/src_es5_tsconfig.json @@ -0,0 +1 @@ +{"compilerOptions": {"target": "es2015", "module": "umd", "downlevelIteration": true, "skipDefaultLibCheck": true, "moduleResolution": "node", "outDir": "../../../../bazel-out/darwin-fastbuild/bin", "rootDir": "../../../..", "rootDirs": ["../../../..", "../../../../bazel-out/darwin-fastbuild/bin", "../../../../bazel-out/darwin-fastbuild/bin"], "baseUrl": "../../../..", "paths": {"@incremental_dom": ["src", "bazel-out/darwin-fastbuild/bin/src", "bazel-out/darwin-fastbuild/bin/src"], "@incremental_dom/*": ["src/*", "bazel-out/darwin-fastbuild/bin/src/*", "bazel-out/darwin-fastbuild/bin/src/*"], "*": ["external/npm/node_modules/*", "external/npm/node_modules/@types/*"], "incremental_dom/*": ["./*", "bazel-out/darwin-fastbuild/bin/*", "bazel-out/darwin-fastbuild/bin/*"]}, "preserveConstEnums": false, "experimentalDecorators": true, "emitDecoratorMetadata": true, "jsx": "react", "noErrorTruncation": false, "noEmitOnError": false, "declaration": true, "declarationDir": "../../../../bazel-out/darwin-fastbuild/bin", "stripInternal": true, "inlineSourceMap": true, "inlineSources": true, "sourceMap": false, "typeRoots": ["../../../../external/npm/node_modules/@types"], "types": []}, "bazelOptions": {"workspaceName": "incremental_dom", "target": "//src:src", "package": "src", "tsickleGenerateExterns": true, "tsickleExternsPath": "", "untyped": false, "typeBlackListPaths": [], "ignoreWarningPaths": [], "es5Mode": true, "manifest": "bazel-out/darwin-fastbuild/bin/src/src.es5.MF", "compilationTargetSrc": ["src/debug.ts", "src/assertions.ts", "src/attributes.ts", "src/changes.ts", "src/context.ts", "src/core.ts", "src/diff.ts", "src/dom_util.ts", "src/global.ts", "src/node_data.ts", "src/nodes.ts", "src/notifications.ts", "src/symbols.ts", "src/types.ts", "src/util.ts", "src/virtual_elements.ts"], "addDtsClutzAliases": false, "typeCheckDependencies": false, "expectedDiagnostics": [], "typeCheck": true, "allowedStrictDeps": ["src/debug.ts", "src/assertions.ts", "src/attributes.ts", "src/changes.ts", "src/context.ts", "src/core.ts", "src/diff.ts", "src/dom_util.ts", "src/global.ts", "src/node_data.ts", "src/nodes.ts", "src/notifications.ts", "src/symbols.ts", "src/types.ts", "src/util.ts", "src/virtual_elements.ts"], "moduleName": "@incremental_dom", "nodeModulesPrefix": "external/npm/node_modules"}, "files": ["../../../../external/npm/node_modules/typescript/lib/protocol.d.ts", "../../../../external/npm/node_modules/typescript/lib/tsserverlibrary.d.ts", "../../../../external/npm/node_modules/typescript/lib/typescript.d.ts", "../../../../external/npm/node_modules/typescript/lib/typescriptServices.d.ts", "../../../../src/debug.ts", "../../../../src/assertions.ts", "../../../../src/attributes.ts", "../../../../src/changes.ts", "../../../../src/context.ts", "../../../../src/core.ts", "../../../../src/diff.ts", "../../../../src/dom_util.ts", "../../../../src/global.ts", "../../../../src/node_data.ts", "../../../../src/nodes.ts", "../../../../src/notifications.ts", "../../../../src/symbols.ts", "../../../../src/types.ts", "../../../../src/util.ts", "../../../../src/virtual_elements.ts"], "compileOnSave": false, "extends": "../../../../tsconfig"} \ No newline at end of file diff --git a/closure/src/symbols.d.ts b/closure/src/symbols.d.ts new file mode 100755 index 00000000..4a158503 --- /dev/null +++ b/closure/src/symbols.d.ts @@ -0,0 +1,5 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +declare const symbols: { + default: string; +}; +export { symbols }; diff --git a/closure/src/symbols.js b/closure/src/symbols.js new file mode 100755 index 00000000..8c7d082c --- /dev/null +++ b/closure/src/symbols.js @@ -0,0 +1,16 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/symbols.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +goog.module('incrementaldom.src.symbols'); +var module = module || { id: 'src/symbols.js' }; +goog.require('tslib'); +/** @type {{default: string}} */ +const symbols = { + default: "__default" +}; +exports.symbols = symbols; +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3ltYm9scy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zeW1ib2xzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7O01BR00sT0FBTyxHQUFHO0lBQ2QsT0FBTyxFQUFFLFdBQVc7Q0FDckI7QUFFUSwwQkFBTyIsInNvdXJjZXNDb250ZW50IjpbIi8vICBDb3B5cmlnaHQgMjAxOCBUaGUgSW5jcmVtZW50YWwgRE9NIEF1dGhvcnMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4vKiogQGxpY2Vuc2UgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjAgKi9cblxuY29uc3Qgc3ltYm9scyA9IHtcbiAgZGVmYXVsdDogXCJfX2RlZmF1bHRcIlxufTtcblxuZXhwb3J0IHsgc3ltYm9scyB9O1xuIl19 \ No newline at end of file diff --git a/closure/src/types.d.ts b/closure/src/types.d.ts new file mode 100755 index 00000000..56f9feeb --- /dev/null +++ b/closure/src/types.d.ts @@ -0,0 +1,16 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +export interface ElementConstructor { + new (): Element; +} +export declare type AttrMutator = (a: Element, b: string, c: any) => void; +export interface AttrMutatorConfig { + [x: string]: AttrMutator; +} +export declare type NameOrCtorDef = string | ElementConstructor; +export declare type Key = string | number | null | undefined; +export declare type Statics = Array<{}> | null | undefined; +export declare type PatchFunction = (node: Element | DocumentFragment, template: (a: T | undefined) => void, data?: T | undefined) => R; +export declare type MatchFnDef = (matchNode: Node, nameOrCtor: NameOrCtorDef, expectedNameOrCtor: NameOrCtorDef, key: Key, expectedKey: Key) => boolean; +export interface PatchConfig { + matches?: MatchFnDef; +} diff --git a/closure/src/types.js b/closure/src/types.js new file mode 100755 index 00000000..132af7da --- /dev/null +++ b/closure/src/types.js @@ -0,0 +1,43 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/types.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +goog.module('incrementaldom.src.types'); +var module = module || { id: 'src/types.js' }; +goog.require('tslib'); +/** + * @record + */ +function ElementConstructor() { } +exports.ElementConstructor = ElementConstructor; +/** @typedef {function(!Element, string, ?): void} */ +exports.AttrMutator; +/** + * @record + */ +function AttrMutatorConfig() { } +exports.AttrMutatorConfig = AttrMutatorConfig; +/** @typedef {(string|!ElementConstructor)} */ +exports.NameOrCtorDef; +/** @typedef {(undefined|null|string|number)} */ +exports.Key; +/** @typedef {(undefined|null|!Array<*>)} */ +exports.Statics; +/** @typedef {function((!DocumentFragment|!Element), function((undefined|?)): void, (undefined|?)=): ?} */ +exports.PatchFunction; +/** @typedef {function(!Node, (string|!ElementConstructor), (string|!ElementConstructor), (undefined|null|string|number), (undefined|null|string|number)): boolean} */ +exports.MatchFnDef; +/** + * @record + */ +function PatchConfig() { } +exports.PatchConfig = PatchConfig; +/* istanbul ignore if */ +if (false) { + /** @type {(undefined|function(!Node, (string|!ElementConstructor), (string|!ElementConstructor), (undefined|null|string|number), (undefined|null|string|number)): boolean)} */ + PatchConfig.prototype.matches; +} +//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7OztBQUdBLGlDQUVDOzs7QUFFRCxvQkFBa0U7Ozs7QUFFbEUsZ0NBRUM7OztBQUVELHNCQUF3RDs7QUFFeEQsWUFBcUQ7O0FBRXJELGdCQUFtRDs7QUFFbkQsc0JBSU87O0FBRVAsbUJBTWE7Ozs7QUFFYiwwQkFFQzs7Ozs7SUFEQyw4QkFBcUIiLCJzb3VyY2VzQ29udGVudCI6WyIvLyAgQ29weXJpZ2h0IDIwMTggVGhlIEluY3JlbWVudGFsIERPTSBBdXRob3JzLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuLyoqIEBsaWNlbnNlIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBBcGFjaGUtMi4wICovXG5cbmV4cG9ydCBpbnRlcmZhY2UgRWxlbWVudENvbnN0cnVjdG9yIHtcbiAgbmV3ICgpOiBFbGVtZW50O1xufVxuXG5leHBvcnQgdHlwZSBBdHRyTXV0YXRvciA9IChhOiBFbGVtZW50LCBiOiBzdHJpbmcsIGM6IGFueSkgPT4gdm9pZDtcblxuZXhwb3J0IGludGVyZmFjZSBBdHRyTXV0YXRvckNvbmZpZyB7XG4gIFt4OiBzdHJpbmddOiBBdHRyTXV0YXRvcjtcbn1cblxuZXhwb3J0IHR5cGUgTmFtZU9yQ3RvckRlZiA9IHN0cmluZyB8IEVsZW1lbnRDb25zdHJ1Y3RvcjtcblxuZXhwb3J0IHR5cGUgS2V5ID0gc3RyaW5nIHwgbnVtYmVyIHwgbnVsbCB8IHVuZGVmaW5lZDtcblxuZXhwb3J0IHR5cGUgU3RhdGljcyA9IEFycmF5PHt9PiB8IG51bGwgfCB1bmRlZmluZWQ7XG5cbmV4cG9ydCB0eXBlIFBhdGNoRnVuY3Rpb248VCwgUj4gPSAoXG4gIG5vZGU6IEVsZW1lbnQgfCBEb2N1bWVudEZyYWdtZW50LFxuICB0ZW1wbGF0ZTogKGE6IFQgfCB1bmRlZmluZWQpID0+IHZvaWQsXG4gIGRhdGE/OiBUIHwgdW5kZWZpbmVkXG4pID0+IFI7XG5cbmV4cG9ydCB0eXBlIE1hdGNoRm5EZWYgPSAoXG4gIG1hdGNoTm9kZTogTm9kZSxcbiAgbmFtZU9yQ3RvcjogTmFtZU9yQ3RvckRlZixcbiAgZXhwZWN0ZWROYW1lT3JDdG9yOiBOYW1lT3JDdG9yRGVmLFxuICBrZXk6IEtleSxcbiAgZXhwZWN0ZWRLZXk6IEtleVxuKSA9PiBib29sZWFuO1xuXG5leHBvcnQgaW50ZXJmYWNlIFBhdGNoQ29uZmlnIHtcbiAgbWF0Y2hlcz86IE1hdGNoRm5EZWY7XG59XG4iXX0= \ No newline at end of file diff --git a/closure/src/util.d.ts b/closure/src/util.d.ts new file mode 100755 index 00000000..dcf36a40 --- /dev/null +++ b/closure/src/util.d.ts @@ -0,0 +1,27 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +/** + * Used to prevent property collisions between our "map" and its prototype. + * @param map The map to check. + * @param property The property to check. + * @return Whether map has property. + */ +declare function has(map: object, property: string): boolean; +/** + * Creates an map object without a prototype. + * @returns An Object that can be used as a map. + */ +declare function createMap(): any; +/** + * Truncates an array, removing items up until length. + * @param arr The array to truncate. + * @param length The new length of the array. + */ +declare function truncateArray(arr: Array<{} | null | undefined>, length: number): void; +/** + * Creates an array for a desired initial size. Note that the array will still + * be empty. + * @param initialAllocationSize The initial size to allocate. + * @returns An empty array, with an initial allocation for the desired size. + */ +declare function createArray(initialAllocationSize: number): Array; +export { createArray, createMap, has, truncateArray }; diff --git a/closure/src/util.js b/closure/src/util.js new file mode 100755 index 00000000..41d4f2f8 --- /dev/null +++ b/closure/src/util.js @@ -0,0 +1,66 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/util.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +goog.module('incrementaldom.src.util'); +var module = module || { id: 'src/util.js' }; +goog.require('tslib'); +/** + * A cached reference to the hasOwnProperty function. + * @type {function((string|number|symbol)): boolean} + */ +const hasOwnProperty = Object.prototype.hasOwnProperty; +/** + * A constructor function that will create blank objects. + * @return {void} + */ +function Blank() { } +Blank.prototype = Object.create(null); +/** + * Used to prevent property collisions between our "map" and its prototype. + * @param {!Object} map The map to check. + * @param {string} property The property to check. + * @return {boolean} Whether map has property. + */ +function has(map, property) { + return hasOwnProperty.call(map, property); +} +exports.has = has; +/** + * Creates an map object without a prototype. + * @return {?} An Object that can be used as a map. + */ +function createMap() { + return new ((/** @type {?} */ (Blank)))(); +} +exports.createMap = createMap; +/** + * Truncates an array, removing items up until length. + * @param {!Array<(undefined|null|*)>} arr The array to truncate. + * @param {number} length The new length of the array. + * @return {void} + */ +function truncateArray(arr, length) { + while (arr.length > length) { + arr.pop(); + } +} +exports.truncateArray = truncateArray; +/** + * Creates an array for a desired initial size. Note that the array will still + * be empty. + * @template T + * @param {number} initialAllocationSize The initial size to allocate. + * @return {!Array} An empty array, with an initial allocation for the desired size. + */ +function createArray(initialAllocationSize) { + /** @type {!Array} */ + const arr = new Array(initialAllocationSize); + truncateArray(arr, 0); + return arr; +} +exports.createArray = createArray; +//# sourceMappingURL=data:application/json;base64,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 \ No newline at end of file diff --git a/closure/src/virtual_elements.d.ts b/closure/src/virtual_elements.d.ts new file mode 100755 index 00000000..0ad30e29 --- /dev/null +++ b/closure/src/virtual_elements.d.ts @@ -0,0 +1,96 @@ +/** @license SPDX-License-Identifier: Apache-2.0 */ +import { AttrMutatorConfig, Key, NameOrCtorDef, Statics } from "./types"; +/** + * Declares a virtual Element at the current location in the document. This + * corresponds to an opening tag and a elementClose tag is required. This is + * like elementOpen, but the attributes are defined using the attr function + * rather than being passed as arguments. Must be folllowed by 0 or more calls + * to attr, then a call to elementOpenEnd. + * @param nameOrCtor The Element's tag or constructor. + * @param key The key used to identify this element. This can be an + * empty string, but performance may be better if a unique value is used + * when iterating over an array of items. + * @param statics An array of attribute name/value pairs of the static + * attributes for the Element. Attributes will only be set once when the + * Element is created. + */ +declare function elementOpenStart(nameOrCtor: NameOrCtorDef, key?: Key, statics?: Statics): void; +/** + * Allows you to define a key after an elementOpenStart. This is useful in + * templates that define key after an element has been opened ie + * `
`. + * @param key The key to use for the next call. + */ +declare function key(key: string): void; +/** + * Buffers an attribute, which will get applied during the next call to + * `elementOpen`, `elementOpenEnd` or `applyAttrs`. + * @param name The of the attribute to buffer. + * @param value The value of the attribute to buffer. + */ +declare function attr(name: string, value: any): void; +/** + * Closes an open tag started with elementOpenStart. + * @return The corresponding Element. + */ +declare function elementOpenEnd(): HTMLElement; +/** + * @param nameOrCtor The Element's tag or constructor. + * @param key The key used to identify this element. This can be an + * empty string, but performance may be better if a unique value is used + * when iterating over an array of items. + * @param statics An array of attribute name/value pairs of the static + * attributes for the Element. Attributes will only be set once when the + * Element is created. + * @param varArgs, Attribute name/value pairs of the dynamic attributes + * for the Element. + * @return The corresponding Element. + */ +declare function elementOpen(nameOrCtor: NameOrCtorDef, key?: Key, statics?: Statics, ...varArgs: Array): HTMLElement; +/** + * Applies the currently buffered attrs to the currently open element. This + * clears the buffered attributes. + * @param attrs The attributes. + */ +declare function applyAttrs(attrs?: AttrMutatorConfig): void; +/** + * Applies the current static attributes to the currently open element. Note: + * statics should be applied before calling `applyAtrs`. + * @param statics The statics to apply to the current element. + * @param attrs The attributes. + */ +declare function applyStatics(statics: Statics, attrs?: AttrMutatorConfig): void; +/** + * Closes an open virtual Element. + * + * @param nameOrCtor The Element's tag or constructor. + * @return The corresponding Element. + */ +declare function elementClose(nameOrCtor: NameOrCtorDef): Element; +/** + * Declares a virtual Element at the current location in the document that has + * no children. + * @param nameOrCtor The Element's tag or constructor. + * @param key The key used to identify this element. This can be an + * empty string, but performance may be better if a unique value is used + * when iterating over an array of items. + * @param statics An array of attribute name/value pairs of the static + * attributes for the Element. Attributes will only be set once when the + * Element is created. + * @param varArgs Attribute name/value pairs of the dynamic attributes + * for the Element. + * @return The corresponding Element. + */ +declare function elementVoid(nameOrCtor: NameOrCtorDef, key?: Key, statics?: Statics, ...varArgs: Array): Element; +/** + * Declares a virtual Text at this point in the document. + * + * @param value The value of the Text. + * @param varArgs + * Functions to format the value which are called only when the value has + * changed. + * @return The corresponding text node. + */ +declare function text(value: string | number | boolean, ...varArgs: Array<(a: {}) => string>): Text; +/** */ +export { applyAttrs, applyStatics, elementOpenStart, elementOpenEnd, elementOpen, elementVoid, elementClose, text, attr, key }; diff --git a/closure/src/virtual_elements.js b/closure/src/virtual_elements.js new file mode 100755 index 00000000..17efde1d --- /dev/null +++ b/closure/src/virtual_elements.js @@ -0,0 +1,344 @@ +/** + * @fileoverview added by tsickle + * Generated from: src/virtual_elements.ts + * @suppress {checkTypes,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc + */ +goog.module('incrementaldom.src.virtual_elements'); +var module = module || { id: 'src/virtual_elements.js' }; +goog.require('tslib'); +const tsickle_assertions_1 = goog.requireType("incrementaldom.src.assertions"); +const tsickle_attributes_2 = goog.requireType("incrementaldom.src.attributes"); +const tsickle_core_3 = goog.requireType("incrementaldom.src.core"); +const tsickle_global_4 = goog.requireType("incrementaldom.src.global"); +const tsickle_node_data_5 = goog.requireType("incrementaldom.src.node_data"); +const tsickle_types_6 = goog.requireType("incrementaldom.src.types"); +const tsickle_util_7 = goog.requireType("incrementaldom.src.util"); +const tsickle_diff_8 = goog.requireType("incrementaldom.src.diff"); +// Copyright 2018 The Incremental DOM Authors. All Rights Reserved. +/** @license SPDX-License-Identifier: Apache-2.0 */ +var assertions_1 = goog.require('incrementaldom.src.assertions'); +var attributes_1 = goog.require('incrementaldom.src.attributes'); +var core_1 = goog.require('incrementaldom.src.core'); +var global_1 = goog.require('incrementaldom.src.global'); +var node_data_1 = goog.require('incrementaldom.src.node_data'); +var util_1 = goog.require('incrementaldom.src.util'); +var diff_1 = goog.require('incrementaldom.src.diff'); +/** + * The offset in the virtual element declaration where the attributes are + * specified. + * @type {number} + */ +const ATTRIBUTES_OFFSET = 3; +/** + * Used to keep track of the previous values when a 2-way diff is necessary. + * This object is reused. + * TODO(sparhamI) Scope this to a patch so you can call patch from an attribute + * update. + * @type {?} + */ +const prevAttrsMap = util_1.createMap(); +/** + * @param {!Element} element The Element to diff the attrs for. + * @param {!tsickle_node_data_5.NodeData} data The NodeData associated with the Element. + * @param {!tsickle_types_6.AttrMutatorConfig} attrs The attribute map of mutators + * @return {void} + */ +function diffAttrs(element, data, attrs) { + /** @type {!Array} */ + const attrsBuilder = core_1.getAttrsBuilder(); + /** @type {!Array} */ + const prevAttrsArr = data.getAttrsArr(attrsBuilder.length); + diff_1.calculateDiff(prevAttrsArr, attrsBuilder, element, attributes_1.updateAttribute, attrs, data.alwaysDiffAttributes); + util_1.truncateArray(attrsBuilder, 0); +} +/** + * Applies the statics. When importing an Element, any existing attributes that + * match a static are converted into a static attribute. + * @param {!Element} node The Element to apply statics for. + * @param {!tsickle_node_data_5.NodeData} data The NodeData associated with the Element. + * @param {(undefined|null|!Array<*>)} statics The statics array. + * @param {!tsickle_types_6.AttrMutatorConfig} attrs The attribute map of mutators. + * @return {void} + */ +function diffStatics(node, data, statics, attrs) { + if (data.staticsApplied) { + return; + } + data.staticsApplied = true; + if (!statics || !statics.length) { + return; + } + if (data.hasEmptyAttrsArr()) { + for (let i = 0; i < statics.length; i += 2) { + attributes_1.updateAttribute(node, (/** @type {string} */ (statics[i])), statics[i + 1], attrs); + } + return; + } + for (let i = 0; i < statics.length; i += 2) { + prevAttrsMap[(/** @type {string} */ (statics[i]))] = i + 1; + } + /** @type {!Array} */ + const attrsArr = data.getAttrsArr(0); + /** @type {number} */ + let j = 0; + for (let i = 0; i < attrsArr.length; i += 2) { + /** @type {?} */ + const name = attrsArr[i]; + /** @type {?} */ + const value = attrsArr[i + 1]; + /** @type {?} */ + const staticsIndex = prevAttrsMap[name]; + if (staticsIndex) { + // For any attrs that are static and have the same value, make sure we do + // not set them again. + if (statics[staticsIndex] === value) { + delete prevAttrsMap[name]; + } + continue; + } + // For any attrs that are dynamic, move them up to the right place. + attrsArr[j] = name; + attrsArr[j + 1] = value; + j += 2; + } + // Anything after `j` was either moved up already or static. + util_1.truncateArray(attrsArr, j); + for (const name in prevAttrsMap) { + attributes_1.updateAttribute(node, name, statics[prevAttrsMap[name]], attrs); + delete prevAttrsMap[name]; + } +} +/** + * Declares a virtual Element at the current location in the document. This + * corresponds to an opening tag and a elementClose tag is required. This is + * like elementOpen, but the attributes are defined using the attr function + * rather than being passed as arguments. Must be folllowed by 0 or more calls + * to attr, then a call to elementOpenEnd. + * @param {(string|!tsickle_types_6.ElementConstructor)} nameOrCtor The Element's tag or constructor. + * @param {(undefined|null|string|number)=} key The key used to identify this element. This can be an + * empty string, but performance may be better if a unique value is used + * when iterating over an array of items. + * @param {(undefined|null|!Array<*>)=} statics An array of attribute name/value pairs of the static + * attributes for the Element. Attributes will only be set once when the + * Element is created. + * @return {void} + */ +function elementOpenStart(nameOrCtor, key, statics) { + /** @type {!Array} */ + const argsBuilder = core_1.getArgsBuilder(); + if (global_1.DEBUG) { + assertions_1.assertNotInAttributes("elementOpenStart"); + assertions_1.setInAttributes(true); + } + argsBuilder[0] = nameOrCtor; + argsBuilder[1] = key; + argsBuilder[2] = statics; +} +exports.elementOpenStart = elementOpenStart; +/** + * Allows you to define a key after an elementOpenStart. This is useful in + * templates that define key after an element has been opened ie + * `
`. + * @param {string} key The key to use for the next call. + * @return {void} + */ +function key(key) { + /** @type {!Array} */ + const argsBuilder = core_1.getArgsBuilder(); + if (global_1.DEBUG) { + assertions_1.assertInAttributes("key"); + assertions_1.assert(argsBuilder); + } + argsBuilder[1] = key; +} +exports.key = key; +/** + * Buffers an attribute, which will get applied during the next call to + * `elementOpen`, `elementOpenEnd` or `applyAttrs`. + * @param {string} name The of the attribute to buffer. + * @param {?} value The value of the attribute to buffer. + * @return {void} + */ +function attr(name, value) { + /** @type {!Array} */ + const attrsBuilder = core_1.getAttrsBuilder(); + if (global_1.DEBUG) { + assertions_1.assertInPatch("attr"); + } + attrsBuilder.push(name); + attrsBuilder.push(value); +} +exports.attr = attr; +/** + * @return {string} The value of the nonce attribute. + */ +function getNonce() { + /** @type {!Array} */ + const argsBuilder = core_1.getArgsBuilder(); + /** @type {(undefined|null|!Array<*>)} */ + const statics = (/** @type {(undefined|null|!Array<*>)} */ (argsBuilder[2])); + if (statics) { + for (let i = 0; i < statics.length; i += 2) { + if (statics[i] === "nonce") { + return (/** @type {string} */ (statics[i + 1])); + } + } + } + return ""; +} +/** + * Closes an open tag started with elementOpenStart. + * @return {!HTMLElement} The corresponding Element. + */ +function elementOpenEnd() { + /** @type {!Array} */ + const argsBuilder = core_1.getArgsBuilder(); + if (global_1.DEBUG) { + assertions_1.assertInAttributes("elementOpenEnd"); + assertions_1.setInAttributes(false); + } + /** @type {!HTMLElement} */ + const node = core_1.open((/** @type {(string|!tsickle_types_6.ElementConstructor)} */ (argsBuilder[0])), (/** @type {(undefined|null|string|number)} */ (argsBuilder[1])), getNonce()); + /** @type {!tsickle_node_data_5.NodeData} */ + const data = node_data_1.getData(node); + diffStatics(node, data, (/** @type {(undefined|null|!Array<*>)} */ (argsBuilder[2])), attributes_1.attributes); + diffAttrs(node, data, attributes_1.attributes); + util_1.truncateArray(argsBuilder, 0); + return node; +} +exports.elementOpenEnd = elementOpenEnd; +/** + * @param {(string|!tsickle_types_6.ElementConstructor)} nameOrCtor The Element's tag or constructor. + * @param {(undefined|null|string|number)=} key The key used to identify this element. This can be an + * empty string, but performance may be better if a unique value is used + * when iterating over an array of items. + * @param {(undefined|null|!Array<*>)=} statics An array of attribute name/value pairs of the static + * attributes for the Element. Attributes will only be set once when the + * Element is created. + * @param {...?} varArgs + * @return {!HTMLElement} The corresponding Element. + */ +function elementOpen(nameOrCtor, key, +// Ideally we could tag statics and varArgs as an array where every odd +// element is a string and every even element is any, but this is hard. +statics, ...varArgs) { + if (global_1.DEBUG) { + assertions_1.assertNotInAttributes("elementOpen"); + assertions_1.assertNotInSkip("elementOpen"); + } + elementOpenStart(nameOrCtor, key, statics); + for (let i = ATTRIBUTES_OFFSET; i < arguments.length; i += 2) { + attr(arguments[i], arguments[i + 1]); + } + return elementOpenEnd(); +} +exports.elementOpen = elementOpen; +/** + * Applies the currently buffered attrs to the currently open element. This + * clears the buffered attributes. + * @param {!tsickle_types_6.AttrMutatorConfig=} attrs The attributes. + * @return {void} + */ +function applyAttrs(attrs = attributes_1.attributes) { + /** @type {!Element} */ + const node = core_1.currentElement(); + /** @type {!tsickle_node_data_5.NodeData} */ + const data = node_data_1.getData(node); + diffAttrs(node, data, attrs); +} +exports.applyAttrs = applyAttrs; +/** + * Applies the current static attributes to the currently open element. Note: + * statics should be applied before calling `applyAtrs`. + * @param {(undefined|null|!Array<*>)} statics The statics to apply to the current element. + * @param {!tsickle_types_6.AttrMutatorConfig=} attrs The attributes. + * @return {void} + */ +function applyStatics(statics, attrs = attributes_1.attributes) { + /** @type {!Element} */ + const node = core_1.currentElement(); + /** @type {!tsickle_node_data_5.NodeData} */ + const data = node_data_1.getData(node); + diffStatics(node, data, statics, attrs); +} +exports.applyStatics = applyStatics; +/** + * Closes an open virtual Element. + * + * @param {(string|!tsickle_types_6.ElementConstructor)} nameOrCtor The Element's tag or constructor. + * @return {!Element} The corresponding Element. + */ +function elementClose(nameOrCtor) { + if (global_1.DEBUG) { + assertions_1.assertNotInAttributes("elementClose"); + } + /** @type {!Element} */ + const node = core_1.close(); + if (global_1.DEBUG) { + assertions_1.assertCloseMatchesOpenTag(node_data_1.getData(node).nameOrCtor, nameOrCtor); + } + return node; +} +exports.elementClose = elementClose; +/** + * Declares a virtual Element at the current location in the document that has + * no children. + * @param {(string|!tsickle_types_6.ElementConstructor)} nameOrCtor The Element's tag or constructor. + * @param {(undefined|null|string|number)=} key The key used to identify this element. This can be an + * empty string, but performance may be better if a unique value is used + * when iterating over an array of items. + * @param {(undefined|null|!Array<*>)=} statics An array of attribute name/value pairs of the static + * attributes for the Element. Attributes will only be set once when the + * Element is created. + * @param {...?} varArgs Attribute name/value pairs of the dynamic attributes + * for the Element. + * @return {!Element} The corresponding Element. + */ +function elementVoid(nameOrCtor, key, +// Ideally we could tag statics and varArgs as an array where every odd +// element is a string and every even element is any, but this is hard. +statics, ...varArgs) { + elementOpen.apply(null, (/** @type {?} */ (arguments))); + return elementClose(nameOrCtor); +} +exports.elementVoid = elementVoid; +/** + * Declares a virtual Text at this point in the document. + * + * @param {(string|number|boolean)} value The value of the Text. + * @param {...function(*): string} varArgs + * Functions to format the value which are called only when the value has + * changed. + * @return {!Text} The corresponding text node. + */ +function text(value, ...varArgs) { + if (global_1.DEBUG) { + assertions_1.assertNotInAttributes("text"); + assertions_1.assertNotInSkip("text"); + } + /** @type {!Text} */ + const node = core_1.text(); + /** @type {!tsickle_node_data_5.NodeData} */ + const data = node_data_1.getData(node); + if (data.text !== value) { + data.text = (/** @type {string} */ (value)); + /** @type {(string|number|boolean)} */ + let formatted = value; + for (let i = 1; i < arguments.length; i += 1) { + /* + * Call the formatter function directly to prevent leaking arguments. + * https://github.com/google/incremental-dom/pull/204#issuecomment-178223574 + */ + /** @type {?} */ + const fn = arguments[i]; + formatted = fn(formatted); + } + // Setting node.data resets the cursor in IE/Edge. + if (node.data !== formatted) { + node.data = (/** @type {string} */ (formatted)); + } + } + return node; +} +exports.text = text; +//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"virtual_elements.js","sourceRoot":"","sources":["../../../../src/virtual_elements.ts"],"names":[],"mappings":"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","sourcesContent":["//  Copyright 2018 The Incremental DOM Authors. All Rights Reserved.\n/** @license SPDX-License-Identifier: Apache-2.0 */\n\nimport {\n  assert,\n  assertCloseMatchesOpenTag,\n  assertInAttributes,\n  assertInPatch,\n  assertNotInAttributes,\n  assertNotInSkip,\n  setInAttributes\n} from \"./assertions\";\nimport { attributes, updateAttribute } from \"./attributes\";\nimport {\n  getArgsBuilder,\n  getAttrsBuilder,\n  close,\n  open,\n  text as coreText,\n  currentElement\n} from \"./core\";\nimport { DEBUG } from \"./global\";\nimport { getData, NodeData } from \"./node_data\";\nimport { AttrMutatorConfig, Key, NameOrCtorDef, Statics } from \"./types\";\nimport { createMap, truncateArray } from \"./util\";\nimport { calculateDiff } from \"./diff\";\n\n/**\n * The offset in the virtual element declaration where the attributes are\n * specified.\n */\nconst ATTRIBUTES_OFFSET = 3;\n\n/**\n * Used to keep track of the previous values when a 2-way diff is necessary.\n * This object is reused.\n * TODO(sparhamI) Scope this to a patch so you can call patch from an attribute\n * update.\n */\nconst prevAttrsMap = createMap();\n\n/**\n * @param element The Element to diff the attrs for.\n * @param data The NodeData associated with the Element.\n * @param attrs The attribute map of mutators\n */\nfunction diffAttrs(element: Element, data: NodeData, attrs: AttrMutatorConfig) {\n  const attrsBuilder = getAttrsBuilder();\n  const prevAttrsArr = data.getAttrsArr(attrsBuilder.length);\n\n  calculateDiff(\n    prevAttrsArr,\n    attrsBuilder,\n    element,\n    updateAttribute,\n    attrs,\n    data.alwaysDiffAttributes\n  );\n  truncateArray(attrsBuilder, 0);\n}\n\n/**\n * Applies the statics. When importing an Element, any existing attributes that\n * match a static are converted into a static attribute.\n * @param node The Element to apply statics for.\n * @param data The NodeData associated with the Element.\n * @param statics The statics array.\n * @param attrs The attribute map of mutators.\n */\nfunction diffStatics(\n  node: Element,\n  data: NodeData,\n  statics: Statics,\n  attrs: AttrMutatorConfig\n) {\n  if (data.staticsApplied) {\n    return;\n  }\n\n  data.staticsApplied = true;\n\n  if (!statics || !statics.length) {\n    return;\n  }\n\n  if (data.hasEmptyAttrsArr()) {\n    for (let i = 0; i < statics.length; i += 2) {\n      updateAttribute(node, statics[i] as string, statics[i + 1], attrs);\n    }\n    return;\n  }\n\n  for (let i = 0; i < statics.length; i += 2) {\n    prevAttrsMap[statics[i] as string] = i + 1;\n  }\n\n  const attrsArr = data.getAttrsArr(0);\n  let j = 0;\n  for (let i = 0; i < attrsArr.length; i += 2) {\n    const name = attrsArr[i];\n    const value = attrsArr[i + 1];\n    const staticsIndex = prevAttrsMap[name];\n\n    if (staticsIndex) {\n      // For any attrs that are static and have the same value, make sure we do\n      // not set them again.\n      if (statics[staticsIndex] === value) {\n        delete prevAttrsMap[name];\n      }\n\n      continue;\n    }\n\n    // For any attrs that are dynamic, move them up to the right place.\n    attrsArr[j] = name;\n    attrsArr[j + 1] = value;\n    j += 2;\n  }\n  // Anything after `j` was either moved up already or static.\n  truncateArray(attrsArr, j);\n\n  for (const name in prevAttrsMap) {\n    updateAttribute(node, name, statics[prevAttrsMap[name]], attrs);\n    delete prevAttrsMap[name];\n  }\n}\n\n/**\n * Declares a virtual Element at the current location in the document. This\n * corresponds to an opening tag and a elementClose tag is required. This is\n * like elementOpen, but the attributes are defined using the attr function\n * rather than being passed as arguments. Must be folllowed by 0 or more calls\n * to attr, then a call to elementOpenEnd.\n * @param nameOrCtor The Element's tag or constructor.\n * @param key The key used to identify this element. This can be an\n *     empty string, but performance may be better if a unique value is used\n *     when iterating over an array of items.\n * @param statics An array of attribute name/value pairs of the static\n *     attributes for the Element. Attributes will only be set once when the\n *     Element is created.\n */\nfunction elementOpenStart(\n  nameOrCtor: NameOrCtorDef,\n  key?: Key,\n  statics?: Statics\n) {\n  const argsBuilder = getArgsBuilder();\n\n  if (DEBUG) {\n    assertNotInAttributes(\"elementOpenStart\");\n    setInAttributes(true);\n  }\n\n  argsBuilder[0] = nameOrCtor;\n  argsBuilder[1] = key;\n  argsBuilder[2] = statics;\n}\n\n/**\n * Allows you to define a key after an elementOpenStart. This is useful in\n * templates that define key after an element has been opened ie\n * `<div key('foo')></div>`.\n * @param key The key to use for the next call.\n */\nfunction key(key: string) {\n  const argsBuilder = getArgsBuilder();\n\n  if (DEBUG) {\n    assertInAttributes(\"key\");\n    assert(argsBuilder);\n  }\n  argsBuilder[1] = key;\n}\n\n/**\n * Buffers an attribute, which will get applied during the next call to\n * `elementOpen`, `elementOpenEnd` or `applyAttrs`.\n * @param name The of the attribute to buffer.\n * @param value The value of the attribute to buffer.\n */\nfunction attr(name: string, value: any) {\n  const attrsBuilder = getAttrsBuilder();\n\n  if (DEBUG) {\n    assertInPatch(\"attr\");\n  }\n\n  attrsBuilder.push(name);\n  attrsBuilder.push(value);\n}\n\n/** @return The value of the nonce attribute. */\nfunction getNonce(): string {\n  const argsBuilder = getArgsBuilder();\n  const statics = <Statics>argsBuilder[2];\n  if (statics) {\n    for (let i = 0; i < statics.length; i += 2) {\n      if (statics[i] === \"nonce\") {\n        return statics[i + 1] as string;\n      }\n    }\n  }\n  return \"\";\n}\n\n/**\n * Closes an open tag started with elementOpenStart.\n * @return The corresponding Element.\n */\nfunction elementOpenEnd(): HTMLElement {\n  const argsBuilder = getArgsBuilder();\n\n  if (DEBUG) {\n    assertInAttributes(\"elementOpenEnd\");\n    setInAttributes(false);\n  }\n\n  const node = open(\n    <NameOrCtorDef>argsBuilder[0],\n    <Key>argsBuilder[1],\n    getNonce()\n  );\n  const data = getData(node);\n\n  diffStatics(node, data, <Statics>argsBuilder[2], attributes);\n  diffAttrs(node, data, attributes);\n  truncateArray(argsBuilder, 0);\n\n  return node;\n}\n\n/**\n * @param  nameOrCtor The Element's tag or constructor.\n * @param  key The key used to identify this element. This can be an\n *     empty string, but performance may be better if a unique value is used\n *     when iterating over an array of items.\n * @param statics An array of attribute name/value pairs of the static\n *     attributes for the Element. Attributes will only be set once when the\n *     Element is created.\n * @param varArgs, Attribute name/value pairs of the dynamic attributes\n *     for the Element.\n * @return The corresponding Element.\n */\nfunction elementOpen(\n  nameOrCtor: NameOrCtorDef,\n  key?: Key,\n  // Ideally we could tag statics and varArgs as an array where every odd\n  // element is a string and every even element is any, but this is hard.\n  statics?: Statics,\n  ...varArgs: Array<any>\n) {\n  if (DEBUG) {\n    assertNotInAttributes(\"elementOpen\");\n    assertNotInSkip(\"elementOpen\");\n  }\n\n  elementOpenStart(nameOrCtor, key, statics);\n\n  for (let i = ATTRIBUTES_OFFSET; i < arguments.length; i += 2) {\n    attr(arguments[i], arguments[i + 1]);\n  }\n\n  return elementOpenEnd();\n}\n\n/**\n * Applies the currently buffered attrs to the currently open element. This\n * clears the buffered attributes.\n * @param attrs The attributes.\n */\nfunction applyAttrs(attrs = attributes) {\n  const node = currentElement();\n  const data = getData(node);\n\n  diffAttrs(node, data, attrs);\n}\n\n/**\n * Applies the current static attributes to the currently open element. Note:\n * statics should be applied before calling `applyAtrs`.\n * @param statics The statics to apply to the current element.\n * @param attrs The attributes.\n */\nfunction applyStatics(statics: Statics, attrs = attributes) {\n  const node = currentElement();\n  const data = getData(node);\n\n  diffStatics(node, data, statics, attrs);\n}\n\n/**\n * Closes an open virtual Element.\n *\n * @param nameOrCtor The Element's tag or constructor.\n * @return The corresponding Element.\n */\nfunction elementClose(nameOrCtor: NameOrCtorDef): Element {\n  if (DEBUG) {\n    assertNotInAttributes(\"elementClose\");\n  }\n\n  const node = close();\n\n  if (DEBUG) {\n    assertCloseMatchesOpenTag(getData(node).nameOrCtor, nameOrCtor);\n  }\n\n  return node;\n}\n\n/**\n * Declares a virtual Element at the current location in the document that has\n * no children.\n * @param nameOrCtor The Element's tag or constructor.\n * @param key The key used to identify this element. This can be an\n *     empty string, but performance may be better if a unique value is used\n *     when iterating over an array of items.\n * @param statics An array of attribute name/value pairs of the static\n *     attributes for the Element. Attributes will only be set once when the\n *     Element is created.\n * @param varArgs Attribute name/value pairs of the dynamic attributes\n *     for the Element.\n * @return The corresponding Element.\n */\nfunction elementVoid(\n  nameOrCtor: NameOrCtorDef,\n  key?: Key,\n  // Ideally we could tag statics and varArgs as an array where every odd\n  // element is a string and every even element is any, but this is hard.\n  statics?: Statics,\n  ...varArgs: Array<any>\n) {\n  elementOpen.apply(null, arguments as any);\n  return elementClose(nameOrCtor);\n}\n\n/**\n * Declares a virtual Text at this point in the document.\n *\n * @param value The value of the Text.\n * @param varArgs\n *     Functions to format the value which are called only when the value has\n *     changed.\n * @return The corresponding text node.\n */\nfunction text(\n  value: string | number | boolean,\n  ...varArgs: Array<(a: {}) => string>\n) {\n  if (DEBUG) {\n    assertNotInAttributes(\"text\");\n    assertNotInSkip(\"text\");\n  }\n\n  const node = coreText();\n  const data = getData(node);\n\n  if (data.text !== value) {\n    data.text = value as string;\n\n    let formatted = value;\n    for (let i = 1; i < arguments.length; i += 1) {\n      /*\n       * Call the formatter function directly to prevent leaking arguments.\n       * https://github.com/google/incremental-dom/pull/204#issuecomment-178223574\n       */\n      const fn = arguments[i];\n      formatted = fn(formatted);\n    }\n\n    // Setting node.data resets the cursor in IE/Edge.\n    if (node.data !== formatted) {\n      node.data = formatted as string;\n    }\n  }\n\n  return node;\n}\n\n/** */\nexport {\n  applyAttrs,\n  applyStatics,\n  elementOpenStart,\n  elementOpenEnd,\n  elementOpen,\n  elementVoid,\n  elementClose,\n  text,\n  attr,\n  key\n};\n"]} \ No newline at end of file diff --git a/external/tsickle.bzl b/external/tsickle.bzl new file mode 100644 index 00000000..4129017b --- /dev/null +++ b/external/tsickle.bzl @@ -0,0 +1,41 @@ +package( + default_visibility = ["//visibility:public"], +) + +load( + "@io_bazel_rules_closure//closure:defs.bzl", + js_module = "closure_js_library", +) + + +filegroup( + name = "extern-src", + srcs = ["externs.js"], +) + +filegroup( + name = "tslib-src", + srcs = ["tslib.js"], +) + +js_module( + name = "extern-lib", + srcs = [":extern-src"], +) + +js_module( + name = "tslib-lib", + srcs = [":tslib-src"], + suppress = [ + "JSC_MISSING_SEMICOLON", + "reportUnknownTypes", + ], +) + +js_module( + name = "tslib", + exports = [ + ":extern-lib", + ":tslib-lib", + ], +) diff --git a/package-lock.json b/package-lock.json index 779817ba..7131b021 100644 --- a/package-lock.json +++ b/package-lock.json @@ -8,12 +8,15 @@ "name": "incremental-dom", "version": "0.7.0", "license": "Apache-2.0", + "dependencies": { + "typescript": "~4.3.2" + }, "devDependencies": { "@bazel/bazelisk": "^1.11.0", - "@bazel/concatjs": "^4.6.0", + "@bazel/concatjs": "4.6.0", "@bazel/ibazel": "^0.15.10", - "@bazel/rollup": "^4.6.0", - "@bazel/typescript": "^4.6.0", + "@bazel/rollup": "4.6.0", + "@bazel/typescript": "4.6.0", "@rollup/plugin-buble": "^0.21.3", "@types/mocha": "^5.0.0", "@types/sinon": "^4.3.0", @@ -37,7 +40,7 @@ "rollup": "^2.63.0", "sinon": "^4.0.0", "sinon-chai": "^2.9.0", - "typescript": "~3.4.1", + "tsickle": "^0.46.0", "uglify-js": "^3.6.0" } }, @@ -366,6 +369,12 @@ "integrity": "sha512-1w52Nyx4Gq47uuu0EVcsHBxZFJgurQ+rTKS3qMHxR1GY2T8c2AJYd6vZoZ9q1rupaDjU0yT+Jc2XTyXkjeMA+Q==", "dev": true }, + "node_modules/@types/minimist": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/@types/minimist/-/minimist-1.2.2.tgz", + "integrity": "sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==", + "dev": true + }, "node_modules/@types/mocha": { "version": "5.2.6", "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-5.2.6.tgz", @@ -2683,9 +2692,9 @@ } }, "node_modules/google-protobuf": { - "version": "3.19.3", - "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.19.3.tgz", - "integrity": "sha512-3GRDj8o9XjcALYjgxNKeD7Wm6w/V8r1Jo4sLYMic9+VaIMLBx8TQeHP9yaoRoDymNONhnkmmveDPyjw/Fpw8+A==", + "version": "3.19.4", + "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.19.4.tgz", + "integrity": "sha512-OIPNCxsG2lkIvf+P5FNfJ/Km95CsXOBecS9ZcAU6m2Rq3svc0Apl9nB3GMDNKfQ9asNv4KjyAqGwPQFrVle3Yg==", "dev": true }, "node_modules/got": { @@ -6191,6 +6200,18 @@ "node": ">=0.10.0" } }, + "node_modules/tsickle": { + "version": "0.46.0", + "resolved": "https://registry.npmjs.org/tsickle/-/tsickle-0.46.0.tgz", + "integrity": "sha512-pEkomf35SZMlCyHJH2A5/4Li8KZprvGcVUz8jcZVArZNBKVOY7YEvDRJcaEWMTOaEzvjcaeDvE95VDyDka0i2Q==", + "dev": true, + "dependencies": { + "@types/minimist": "^1.2.1" + }, + "peerDependencies": { + "typescript": "h-joo/TypeScript#ts45-no-double-comments" + } + }, "node_modules/tslib": { "version": "1.10.0", "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.10.0.tgz", @@ -6247,10 +6268,9 @@ } }, "node_modules/typescript": { - "version": "3.4.5", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.4.5.tgz", - "integrity": "sha512-YycBxUb49UUhdNMU5aJ7z5Ej2XGmaIBL0x34vZ82fn3hGvD+bgrMrVDpatgz2f7YxUMJxMkbWxJZeAvDxVe7Vw==", - "dev": true, + "version": "4.3.5", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.3.5.tgz", + "integrity": "sha512-DqQgihaQ9cUrskJo9kIyW/+g0Vxsk8cDtZ52a3NGh0YNTfpUSArXSohyUGnvbPazEPLu398C0UxmKSOrPumUzA==", "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" @@ -7299,6 +7319,12 @@ "integrity": "sha512-1w52Nyx4Gq47uuu0EVcsHBxZFJgurQ+rTKS3qMHxR1GY2T8c2AJYd6vZoZ9q1rupaDjU0yT+Jc2XTyXkjeMA+Q==", "dev": true }, + "@types/minimist": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/@types/minimist/-/minimist-1.2.2.tgz", + "integrity": "sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==", + "dev": true + }, "@types/mocha": { "version": "5.2.6", "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-5.2.6.tgz", @@ -9213,9 +9239,9 @@ "dev": true }, "google-protobuf": { - "version": "3.19.3", - "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.19.3.tgz", - "integrity": "sha512-3GRDj8o9XjcALYjgxNKeD7Wm6w/V8r1Jo4sLYMic9+VaIMLBx8TQeHP9yaoRoDymNONhnkmmveDPyjw/Fpw8+A==", + "version": "3.19.4", + "resolved": "https://registry.npmjs.org/google-protobuf/-/google-protobuf-3.19.4.tgz", + "integrity": "sha512-OIPNCxsG2lkIvf+P5FNfJ/Km95CsXOBecS9ZcAU6m2Rq3svc0Apl9nB3GMDNKfQ9asNv4KjyAqGwPQFrVle3Yg==", "dev": true }, "got": { @@ -12081,6 +12107,15 @@ "integrity": "sha1-WIeWa7WCpFA6QetST301ARgVphM=", "dev": true }, + "tsickle": { + "version": "0.46.0", + "resolved": "https://registry.npmjs.org/tsickle/-/tsickle-0.46.0.tgz", + "integrity": "sha512-pEkomf35SZMlCyHJH2A5/4Li8KZprvGcVUz8jcZVArZNBKVOY7YEvDRJcaEWMTOaEzvjcaeDvE95VDyDka0i2Q==", + "dev": true, + "requires": { + "@types/minimist": "^1.2.1" + } + }, "tslib": { "version": "1.10.0", "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.10.0.tgz", @@ -12122,10 +12157,9 @@ } }, "typescript": { - "version": "3.4.5", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.4.5.tgz", - "integrity": "sha512-YycBxUb49UUhdNMU5aJ7z5Ej2XGmaIBL0x34vZ82fn3hGvD+bgrMrVDpatgz2f7YxUMJxMkbWxJZeAvDxVe7Vw==", - "dev": true + "version": "4.3.5", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.3.5.tgz", + "integrity": "sha512-DqQgihaQ9cUrskJo9kIyW/+g0Vxsk8cDtZ52a3NGh0YNTfpUSArXSohyUGnvbPazEPLu398C0UxmKSOrPumUzA==" }, "uglify-js": { "version": "3.6.0", diff --git a/package.json b/package.json index 4cd3f104..7a2b010d 100644 --- a/package.json +++ b/package.json @@ -24,10 +24,10 @@ }, "devDependencies": { "@bazel/bazelisk": "^1.11.0", - "@bazel/concatjs": "^4.6.0", + "@bazel/concatjs": "4.6.0", "@bazel/ibazel": "^0.15.10", - "@bazel/rollup": "^4.6.0", - "@bazel/typescript": "^4.6.0", + "@bazel/rollup": "4.6.0", + "@bazel/typescript": "4.6.0", "@rollup/plugin-buble": "^0.21.3", "@types/mocha": "^5.0.0", "@types/sinon": "^4.3.0", @@ -51,7 +51,10 @@ "rollup": "^2.63.0", "sinon": "^4.0.0", "sinon-chai": "^2.9.0", - "typescript": "~3.4.1", + "tsickle": "^0.46.0", "uglify-js": "^3.6.0" + }, + "dependencies": { + "typescript": "~4.3.2" } } diff --git a/release/BUILD b/release/BUILD index a7c2fa51..49e20f43 100644 --- a/release/BUILD +++ b/release/BUILD @@ -1,7 +1,7 @@ package(default_visibility = ["//:__subpackages__"]) load("//:constants.bzl", "RELEASE_FILES") -load("@npm//@bazel/typescript:index.bzl", "ts_library") +load("//tools:ts.bzl", "ts_library") genrule( name = "release_files", @@ -18,5 +18,4 @@ ts_library( "debug.ts", ":release_files", ], - tsickle_typed = True, ) diff --git a/src/BUILD b/src/BUILD index 3118cabe..e6bf7dd2 100644 --- a/src/BUILD +++ b/src/BUILD @@ -1,14 +1,15 @@ package(default_visibility = ["//:__subpackages__"]) -load("@npm//@bazel/typescript:index.bzl", "ts_library") +load("//tools:ts.bzl", "ts_library") load("//:constants.bzl", "RELEASE_FILES") ts_library( name = "src", + package_name = "@incremental_dom/src", + module_name = "@incremental_dom/src", srcs = [ ":all_files", ], - tsickle_typed = True, ) filegroup( diff --git a/test/BUILD b/test/BUILD index 259be4db..31492bcf 100644 --- a/test/BUILD +++ b/test/BUILD @@ -4,6 +4,7 @@ load("@npm//@bazel/typescript:index.bzl", "ts_library") ts_library( name = "test_lib", srcs = glob(["**/*.ts"]), + compiler = "//tools/tsc", deps = [ "//:dev", "//src", diff --git a/tools/BUILD.bazel b/tools/BUILD.bazel new file mode 100644 index 00000000..e69de29b diff --git a/tools/ts.bzl b/tools/ts.bzl new file mode 100644 index 00000000..d7f3364c --- /dev/null +++ b/tools/ts.bzl @@ -0,0 +1,30 @@ + +load("@io_bazel_rules_closure//closure:defs.bzl", _closure_js_library = "closure_js_library") +load("@npm//@bazel/typescript:index.bzl", _ts_library = "ts_library") + + +def ts_library(name, srcs = [], deps = [], **kwargs): + """Proxy rule for declaring TypeScript libraries.""" + + _ts_library( + name = name, + srcs = srcs, + deps = deps, + tsickle_typed = True, + compiler = "//tools/tsc", + **kwargs + ) + + native.filegroup( + name = "%s_es5" % name, + srcs = [":%s" % name], + output_group = "es5_sources", + ) + + _closure_js_library( + name = "%s_closure" % name, + srcs = [":%s_es5" % name], + deps = [ + "@tsickle//:tslib", + ], + ) diff --git a/tools/tsc/BUILD.bazel b/tools/tsc/BUILD.bazel new file mode 100644 index 00000000..58d8e20e --- /dev/null +++ b/tools/tsc/BUILD.bazel @@ -0,0 +1,21 @@ +load( + "@build_bazel_rules_nodejs//:index.bzl", + "nodejs_binary", +) + +package( + default_visibility = ["//visibility:public"], +) + + +nodejs_binary( + name = "tsc", + entry_point = "@npm//:node_modules/@bazel/typescript/internal/tsc_wrapped/tsc_wrapped.js", + templated_args = ["--bazel_patch_module_resolver", "--node_options=--max-old-space-size=2048"], + visibility = ["//visibility:public"], + data = [ + "@npm//@bazel/typescript", + "@npm//tsickle", + "@npm//typescript", + ], +) diff --git a/tsconfig.json b/tsconfig.json index 5f2f7e9a..393f77ba 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -26,5 +26,10 @@ ], "exclude": [ "node_modules" - ] + ], + "bazelOptions": { + "workspaceName": "incrementaldom", + "tsickle": true, + "googmodule": true + } }