diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e57e341 --- /dev/null +++ b/.gitignore @@ -0,0 +1,34 @@ +# Created by .ignore support plugin (hsz.mobi) +### Scala template +*.class +*.log + +# sbt specific +.cache +.history +.lib/ +dist/* +target/ +lib_managed/ +src_managed/ +project/boot/ +project/plugins/project/ + +# Scala-IDE specific +.scala_dependencies +.worksheet + +# ENSIME specific +.ensime_cache/ +.ensime +### SBT template +# Simple Build Tool +# http://www.scala-sbt.org/release/docs/Getting-Started/Directories.html#configuring-version-control + +target/ +lib_managed/ +src_managed/ +project/boot/ +.history +.cache + diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..8f71f43 --- /dev/null +++ b/LICENSE @@ -0,0 +1,202 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/README.md b/README.md new file mode 100644 index 0000000..68426c4 --- /dev/null +++ b/README.md @@ -0,0 +1,45 @@ +Angular Sanitize API for Scala.js +================================ +[angular-sanitize](https://www.npmjs.com/package/angular-sanitize) - angular-sanitize binding for Scala.js. + +### Description + +An `angular-sanitize` binding for Scala.js. + +### Build Dependencies + +* [SBT v0.13.13](http://www.scala-sbt.org/download.html) + +### Build/publish the SDK locally + +```bash + $ sbt clean publish-local +``` + +### Running the tests + +Before running the tests the first time, you must ensure the npm packages are installed: + +```bash +$ npm install +``` + +Then you can run the tests: + +```bash +$ sbt test +``` + +### Artifacts and Resolvers + +To add the `angular-sanitize` binding to your project, add the following to your build.sbt: + +```sbt +libraryDependencies += "io.scalajs.npm" %%% "angular-sanitize" % "1.6.3" +``` + +Optionally, you may add the Sonatype Repository resolver: + +```sbt +resolvers += Resolver.sonatypeRepo("releases") +``` \ No newline at end of file diff --git a/build.sbt b/build.sbt new file mode 100644 index 0000000..001aad0 --- /dev/null +++ b/build.sbt @@ -0,0 +1,76 @@ +import org.scalajs.sbtplugin.ScalaJSPlugin +import org.scalajs.sbtplugin.ScalaJSPlugin.autoImport._ +import sbt.Keys.{libraryDependencies, _} +import sbt._ + +import scala.language.postfixOps + +val apiVersion = "1.6.3" +val scalaJsIOVersion = "0.3.0.6" +val scalaJsVersion = "2.12.1" + +homepage := Some(url("https://github.com/scalajs-io/angular-sanitize")) + +lazy val root = (project in file(".")). + enablePlugins(ScalaJSPlugin). + settings( + name := "angular-sanitize", + organization := "io.scalajs.npm", + description := "A angular-sanitize library for NodeJS", + version := apiVersion, + scalaVersion := scalaJsVersion, + scalacOptions ++= Seq("-deprecation", "-unchecked", "-feature", "-language:implicitConversions", "-Xlint"), + scalacOptions in(Compile, doc) ++= Seq("-no-link-warnings"), + autoCompilerPlugins := true, + scalaJSModuleKind := ModuleKind.CommonJSModule, + libraryDependencies ++= Seq( + "org.scala-lang" % "scala-reflect" % scalaJsVersion, + "org.scalatest" %%% "scalatest" % "3.0.1" % "test", + "io.scalajs.npm" %%% "angular" % apiVersion + )) + +///////////////////////////////////////////////////////////////////////////////// +// Publishing +///////////////////////////////////////////////////////////////////////////////// + +lazy val publishingSettings = Seq( + sonatypeProfileName := "org.xerial", + publishMavenStyle := true, + publishTo := { + val nexus = "https://oss.sonatype.org/" + if (isSnapshot.value) + Some("snapshots" at nexus + "content/repositories/snapshots") + else + Some("releases" at nexus + "service/local/staging/deploy/maven2") + }, + pomExtra := + https://github.com/scalajs-io/angular-sanitize + + + MIT License + http://www.opensource.org/licenses/mit-license.php + + + + scm:git:github.com/scalajs-io/angular-sanitize.git + scm:git:git@github.com:scalajs-io/angular-sanitize.git + github.com/scalajs-io/angular-sanitize.git + + + + ldaniels528 + Lawrence Daniels + lawrence.daniels@gmail.com + io.scalajs + https://github.com/scalajs-io + + Project-Administrator + Developer + + +7 + + +) + +// loads the Scalajs-io root project at sbt startup +onLoad in Global := (Command.process("project root", _: State)) compose (onLoad in Global).value diff --git a/project/build.properties b/project/build.properties new file mode 100644 index 0000000..27e88aa --- /dev/null +++ b/project/build.properties @@ -0,0 +1 @@ +sbt.version=0.13.13 diff --git a/project/plugins.sbt b/project/plugins.sbt new file mode 100644 index 0000000..62e13fc --- /dev/null +++ b/project/plugins.sbt @@ -0,0 +1,18 @@ +// Scala.js + +addSbtPlugin("org.scala-js" % "sbt-scalajs" % "0.6.14") + +// Publishing + +addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "1.1") + +addSbtPlugin("com.typesafe.sbt" % "sbt-pgp" % "0.8.3") + +// Resolvers + +addSbtPlugin("com.geirsson" % "sbt-scalafmt" % "0.5.5") + +resolvers += "Typesafe repository" at "http://repo.typesafe.com/typesafe/releases/" + +resolvers += Resolver.url("scala-js-snapshots", url("http://repo.scala-js.org/repo/snapshots/"))( + Resolver.ivyStylePatterns) diff --git a/src/main/scala/io/scalajs/npm/angularjs/sanitize/Sce.scala b/src/main/scala/io/scalajs/npm/angularjs/sanitize/Sce.scala new file mode 100644 index 0000000..db15fe6 --- /dev/null +++ b/src/main/scala/io/scalajs/npm/angularjs/sanitize/Sce.scala @@ -0,0 +1,245 @@ +package io.scalajs.npm.angularjs.sanitize + +import io.scalajs.npm.angularjs.Provider + +import scala.scalajs.js + +/** + * SCE Service - is a service that provides Strict Contextual Escaping services to AngularJS. + * @see [[https://docs.angularjs.org/api/ng/provider/\$sceDelegateProvider]] + */ +@js.native +trait Sce extends js.Object { + + /** + * Returns a boolean indicating if SCE is enabled. + * @return a boolean indicating if SCE is enabled. + */ + def isEnabled(): Boolean = js.native + + /** + * Converts Angular expression into a function. This is like $parse and is identical + * when the expression is a literal constant. Otherwise, it wraps the expression + * in a call to \$sce.getTrusted(type, result) + * @param `type` The kind of SCE context in which this result will be used. + * @param expression String expression to compile. + * @return a function which represents the compiled expression: + * + */ + def parseAs(`type`: String, expression: String): js.Function2[js.Any, js.Any, js.Any] = js.native + + /** + * Delegates to $sceDelegate.trustAs. As such, returns an object that is trusted by angular for use in specified + * strict contextual escaping contexts (such as ng-bind-html, ng-include, any src attribute interpolation, + * any dom event binding attribute interpolation such as for onclick, etc.) that uses the provided value. + * See * \$sce for enabling strict contextual escaping. + * @param `type` The kind of context in which this value is safe for use. e.g. url, resourceUrl, html, js and css. + * @param value The value that that should be considered trusted/safe. + * @return A value that can be used to stand in for the provided value in places where Angular expects a \$sce.trustAs() return value. + */ + def trustAs(`type`: String, value: js.Any): js.Any = js.native + + /** + * Shorthand method. \$sce.trustAsHtml(value) -> \$sceDelegate.trustAs($sce.HTML, value) + * @param value the given value + * @return + */ + def trustAsHtml(value: js.Any): js.Any = js.native + + /** + * Shorthand method. \$sce.trustAsUrl(value) -> \$sceDelegate.trustAs(\$sce.URL, value) + * @param value The value to trustAs. + * @return An object that can be passed to \$sce.getTrustedUrl(value) to obtain the original value. + * (privileged directives only accept expressions that are either literal constants or are the + * return value of $sce.trustAs.) + */ + def trustAsUrl(value: js.Any): js.Any = js.native + + /** + * Shorthand method. \$sce.trustAsResourceUrl(value) -> \$sceDelegate.trustAs(\$sce.RESOURCE_URL, value) + * @param value The value to trustAs. + * @return An object that can be passed to $sce.getTrustedResourceUrl(value) to obtain the original value. + * (privileged directives only accept expressions that are either literal constants or are the return + * value of $sce.trustAs.) + */ + def trustAsResourceUrl(value: js.Any): js.Any = js.native + + /** + * Shorthand method. \$sce.trustAsJs(value) -> \$sceDelegate.trustAs(\$sce.JS, value) + * @param value The value to trustAs. + * @return An object that can be passed to \$sce.getTrustedJs(value) to obtain the original value. + * (privileged directives only accept expressions that are either literal constants or are + * the return value of \$sce.trustAs.) + */ + def trustAsJs(value: js.Any): js.Any = js.native + + /** + * Delegates to $sceDelegate.getTrusted. As such, takes the result of a $sce.trustAs() call and + * returns the originally supplied value if the queried context type is a supertype of the created type. + * If this condition isn't satisfied, throws an exception. + * @param `type` The kind of context in which this value is to be used. + * @param maybeTrusted The result of a prior $sce.trustAs call. + * @return The value the was originally provided to $sce.trustAs if valid in this context. + * Otherwise, throws an exception. + */ + def getTrusted(`type`: String, maybeTrusted: js.Any): js.Any = js.native + + /** + * Shorthand method. \$sce.getTrustedHtml(value) -> \$sceDelegate.getTrusted(\$sce.HTML, value) + * @param value The value to pass to $sce.getTrusted. + * @return The return value of \$sce.getTrusted(\$sce.HTML, value) + */ + def getTrustedHtml(value: js.Any): js.Any = js.native + + /** + * Shorthand method. \$sce.getTrustedCss(value) -> \$sceDelegate.getTrusted(\$sce.CSS, value) + * @param value The value to pass to $sce.getTrusted. + * @return The return value of \$sce.getTrusted(\$sce.CSS, value) + */ + def getTrustedCss(value: js.Any): js.Any = js.native + + /** + * Shorthand method. \$sce.getTrustedUrl(value) -> \$sceDelegate.getTrusted(\$sce.URL, value) + * @param value The value to pass to $sce.getTrusted. + * @return The return value of $sce.getTrusted($sce.URL, value) + */ + def getTrustedUrl(value: js.Any): js.Any = js.native + + /** + * Shorthand method. \$sce.getTrustedResourceUrl(value) -> \$sceDelegate.getTrusted(\$sce.RESOURCE_URL, value) + * @param value The value to pass to $sceDelegate.getTrusted. + * @return The return value of \$sce.getTrusted(\$sce.RESOURCE_URL, value) + */ + def getTrustedResourceUrl(value: js.Any): js.Any = js.native + + /** + * Shorthand method. \$sce.getTrustedJs(value) -> \$sceDelegate.getTrusted(\$sce.JS, value) + * @param value The value to pass to $sce.getTrusted. + * @return The return value of \$sce.getTrusted(\$sce.JS, value) + */ + def getTrustedJs(value: js.Any): js.Any = js.native + + /** + * Shorthand method. \$sce.parseAsHtml(expression string) -> \$sce.parseAs(\$sce.HTML, value) + * @param expression String expression to compile. + * @return a function which represents the compiled expression: + *