diff options
Diffstat (limited to 'examples/scala-js/library/src/main/scala/scala/scalajs/js/Primitives.scala')
-rw-r--r-- | examples/scala-js/library/src/main/scala/scala/scalajs/js/Primitives.scala | 872 |
1 files changed, 0 insertions, 872 deletions
diff --git a/examples/scala-js/library/src/main/scala/scala/scalajs/js/Primitives.scala b/examples/scala-js/library/src/main/scala/scala/scalajs/js/Primitives.scala deleted file mode 100644 index 1a3d88c..0000000 --- a/examples/scala-js/library/src/main/scala/scala/scalajs/js/Primitives.scala +++ /dev/null @@ -1,872 +0,0 @@ -/* __ *\ -** ________ ___ / / ___ __ ____ Scala.js API ** -** / __/ __// _ | / / / _ | __ / // __/ (c) 2013, LAMP/EPFL ** -** __\ \/ /__/ __ |/ /__/ __ |/_// /_\ \ http://scala-lang.org/ ** -** /____/\___/_/ |_/____/_/ | |__/ /____/ ** -** |/____/ ** -\* */ - - -/** - * All doc-comments marked as "MDN" are by Mozilla Contributors, - * distributed under the Creative Commons Attribution-ShareAlike license from - * https://developer.mozilla.org/en-US/docs/Web/Reference/API - */ -package scala.scalajs.js - -import annotation.JSBracketAccess - -import scala.language.{ dynamics, implicitConversions } -import scala.reflect.ClassTag -import scala.collection.{ immutable, mutable } -import scala.collection.generic.CanBuildFrom - -/** Super-type of all JavaScript values. - * - * All values of a subtype of this trait represent JavaScript values, without - * boxing of proxying of any kind. - */ -sealed trait Any extends scala.AnyRef { -} - -/** Provides implicit conversions from Scala values to JavaScript values. */ -object Any extends LowPrioAnyImplicits { - @inline implicit def fromUnit(value: Unit): prim.Undefined = - value.asInstanceOf[prim.Undefined] - @inline implicit def fromBoolean(value: scala.Boolean): prim.Boolean = - value.asInstanceOf[prim.Boolean] - @inline implicit def fromByte(value: scala.Byte): prim.Number = - value.asInstanceOf[prim.Number] - @inline implicit def fromShort(value: scala.Short): prim.Number = - value.asInstanceOf[prim.Number] - @inline implicit def fromInt(value: scala.Int): prim.Number = - value.asInstanceOf[prim.Number] - @inline implicit def fromLong(value: scala.Long): prim.Number = - value.toDouble.asInstanceOf[prim.Number] - @inline implicit def fromFloat(value: scala.Float): prim.Number = - value.asInstanceOf[prim.Number] - @inline implicit def fromDouble(value: scala.Double): prim.Number = - value.asInstanceOf[prim.Number] - @inline implicit def fromString(s: java.lang.String): prim.String = - s.asInstanceOf[prim.String] - - @inline implicit def toDouble(value: prim.Number): scala.Double = - value.asInstanceOf[scala.Double] - @inline implicit def toBoolean(value: prim.Boolean): scala.Boolean = - value.asInstanceOf[scala.Boolean] - @inline implicit def toScalaString(value: prim.String): java.lang.String = - value.asInstanceOf[java.lang.String] - - implicit def jsArrayOps[A](array: Array[A]): ArrayOps[A] = - new ArrayOps(array) - - implicit def canBuildFromArray[A]: CanBuildFrom[Array[_], A, Array[A]] = { - @inline - class CanBuildFromArray extends CanBuildFrom[Array[_], A, Array[A]] { - def apply(from: Array[_]): mutable.Builder[A, Array[A]] = - new ArrayOps[A] - def apply(): mutable.Builder[A, Array[A]] = - new ArrayOps[A] - } - new CanBuildFromArray - } - - implicit def fromFunction0[R](f: scala.Function0[R]): Function0[R] = sys.error("stub") - implicit def fromFunction1[T1, R](f: scala.Function1[T1, R]): Function1[T1, R] = sys.error("stub") - implicit def fromFunction2[T1, T2, R](f: scala.Function2[T1, T2, R]): Function2[T1, T2, R] = sys.error("stub") - implicit def fromFunction3[T1, T2, T3, R](f: scala.Function3[T1, T2, T3, R]): Function3[T1, T2, T3, R] = sys.error("stub") - implicit def fromFunction4[T1, T2, T3, T4, R](f: scala.Function4[T1, T2, T3, T4, R]): Function4[T1, T2, T3, T4, R] = sys.error("stub") - implicit def fromFunction5[T1, T2, T3, T4, T5, R](f: scala.Function5[T1, T2, T3, T4, T5, R]): Function5[T1, T2, T3, T4, T5, R] = sys.error("stub") - implicit def fromFunction6[T1, T2, T3, T4, T5, T6, R](f: scala.Function6[T1, T2, T3, T4, T5, T6, R]): Function6[T1, T2, T3, T4, T5, T6, R] = sys.error("stub") - implicit def fromFunction7[T1, T2, T3, T4, T5, T6, T7, R](f: scala.Function7[T1, T2, T3, T4, T5, T6, T7, R]): Function7[T1, T2, T3, T4, T5, T6, T7, R] = sys.error("stub") - implicit def fromFunction8[T1, T2, T3, T4, T5, T6, T7, T8, R](f: scala.Function8[T1, T2, T3, T4, T5, T6, T7, T8, R]): Function8[T1, T2, T3, T4, T5, T6, T7, T8, R] = sys.error("stub") - implicit def fromFunction9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](f: scala.Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]): Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R] = sys.error("stub") - implicit def fromFunction10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R](f: scala.Function10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]): Function10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R] = sys.error("stub") - implicit def fromFunction11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R](f: scala.Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]): Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R] = sys.error("stub") - implicit def fromFunction12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R](f: scala.Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]): Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R] = sys.error("stub") - implicit def fromFunction13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R](f: scala.Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]): Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R] = sys.error("stub") - implicit def fromFunction14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R](f: scala.Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]): Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R] = sys.error("stub") - implicit def fromFunction15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R](f: scala.Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]): Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R] = sys.error("stub") - implicit def fromFunction16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R](f: scala.Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]): Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R] = sys.error("stub") - implicit def fromFunction17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R](f: scala.Function17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]): Function17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R] = sys.error("stub") - implicit def fromFunction18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R](f: scala.Function18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]): Function18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R] = sys.error("stub") - implicit def fromFunction19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R](f: scala.Function19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]): Function19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R] = sys.error("stub") - implicit def fromFunction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R](f: scala.Function20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]): Function20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R] = sys.error("stub") - implicit def fromFunction21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R](f: scala.Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]): Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R] = sys.error("stub") - implicit def fromFunction22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R](f: scala.Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R]): Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R] = sys.error("stub") - - implicit def toFunction0[R](f: Function0[R]): scala.Function0[R] = () => f() - implicit def toFunction1[T1, R](f: Function1[T1, R]): scala.Function1[T1, R] = (x1) => f(x1) - implicit def toFunction2[T1, T2, R](f: Function2[T1, T2, R]): scala.Function2[T1, T2, R] = (x1, x2) => f(x1, x2) - implicit def toFunction3[T1, T2, T3, R](f: Function3[T1, T2, T3, R]): scala.Function3[T1, T2, T3, R] = (x1, x2, x3) => f(x1, x2, x3) - implicit def toFunction4[T1, T2, T3, T4, R](f: Function4[T1, T2, T3, T4, R]): scala.Function4[T1, T2, T3, T4, R] = (x1, x2, x3, x4) => f(x1, x2, x3, x4) - implicit def toFunction5[T1, T2, T3, T4, T5, R](f: Function5[T1, T2, T3, T4, T5, R]): scala.Function5[T1, T2, T3, T4, T5, R] = (x1, x2, x3, x4, x5) => f(x1, x2, x3, x4, x5) - implicit def toFunction6[T1, T2, T3, T4, T5, T6, R](f: Function6[T1, T2, T3, T4, T5, T6, R]): scala.Function6[T1, T2, T3, T4, T5, T6, R] = (x1, x2, x3, x4, x5, x6) => f(x1, x2, x3, x4, x5, x6) - implicit def toFunction7[T1, T2, T3, T4, T5, T6, T7, R](f: Function7[T1, T2, T3, T4, T5, T6, T7, R]): scala.Function7[T1, T2, T3, T4, T5, T6, T7, R] = (x1, x2, x3, x4, x5, x6, x7) => f(x1, x2, x3, x4, x5, x6, x7) - implicit def toFunction8[T1, T2, T3, T4, T5, T6, T7, T8, R](f: Function8[T1, T2, T3, T4, T5, T6, T7, T8, R]): scala.Function8[T1, T2, T3, T4, T5, T6, T7, T8, R] = (x1, x2, x3, x4, x5, x6, x7, x8) => f(x1, x2, x3, x4, x5, x6, x7, x8) - implicit def toFunction9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](f: Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]): scala.Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9) - implicit def toFunction10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R](f: Function10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]): scala.Function10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) - implicit def toFunction11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R](f: Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]): scala.Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) - implicit def toFunction12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R](f: Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]): scala.Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) - implicit def toFunction13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R](f: Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]): scala.Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) - implicit def toFunction14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R](f: Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R]): scala.Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) - implicit def toFunction15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R](f: Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R]): scala.Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) - implicit def toFunction16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R](f: Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R]): scala.Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) - implicit def toFunction17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R](f: Function17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R]): scala.Function17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) - implicit def toFunction18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R](f: Function18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]): scala.Function18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) - implicit def toFunction19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R](f: Function19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]): scala.Function19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) - implicit def toFunction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R](f: Function20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]): scala.Function20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) - implicit def toFunction21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R](f: Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R]): scala.Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) - implicit def toFunction22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R](f: Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R]): scala.Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) -} - -trait LowPrioAnyImplicits { - @inline implicit def richDouble(num: prim.Number): scala.runtime.RichDouble = - new scala.runtime.RichDouble(Any.toDouble(num)) - @inline implicit def richBoolean(b: prim.Boolean): scala.runtime.RichBoolean = - new scala.runtime.RichBoolean(Any.toBoolean(b)) - - @inline implicit def stringOps(string: prim.String): immutable.StringOps = - new immutable.StringOps(Any.toScalaString(string)) - - implicit def wrapArray[A](array: Array[A]): WrappedArray[A] = - new WrappedArray(array) - implicit def wrapDictionary[A](dict: Dictionary[A]): WrappedDictionary[A] = - new WrappedDictionary(dict) -} - -/** Dynamically typed JavaScript value. - * - * Values of this trait accept all possible JavaScript operations in a - * dynamically typed way. You can read and write any field, call any method, - * apply any JavaScript operator to values of this type. - */ -sealed trait Dynamic extends Any with scala.Dynamic { - /** Calls a method of this object. */ - def applyDynamic(name: java.lang.String)(args: Any*): Dynamic = sys.error("stub") - - /** Reads a field of this object. */ - def selectDynamic(name: java.lang.String): Dynamic = sys.error("stub") - - /** Writes a field of this object. */ - def updateDynamic(name: java.lang.String)(value: Any): Unit = sys.error("stub") - - /** Calls this object as a callable. */ - def apply(args: Any*): Dynamic = native - - import prim.Number - - def unary_!(): Boolean = native - - def unary_+(): Number = native - def unary_-(): Number = native - def unary_~(): Number = native - - def +(that: Number): Dynamic = native // could be a String if this is a String - def -(that: Number): Number = native - def *(that: Number): Number = native - def /(that: Number): Number = native - def %(that: Number): Number = native - def <<(that: Number): Number = native - def >>(that: Number): Number = native - def >>>(that: Number): Number = native - def &(that: Number): Number = native - def |(that: Number): Number = native - def ^(that: Number): Number = native - - def +(that: Dynamic): Dynamic = native // could be String if this or that is a String - def -(that: Dynamic): Number = native - def *(that: Dynamic): Number = native - def /(that: Dynamic): Number = native - def %(that: Dynamic): Number = native - def <<(that: Dynamic): Number = native - def >>(that: Dynamic): Number = native - def >>>(that: Dynamic): Number = native - def &(that: Dynamic): Number = native - def |(that: Dynamic): Number = native - def ^(that: Dynamic): Number = native - - def <(that: Number): Boolean = native - def >(that: Number): Boolean = native - def <=(that: Number): Boolean = native - def >=(that: Number): Boolean = native - - def <(that: String): Boolean = native - def >(that: String): Boolean = native - def <=(that: String): Boolean = native - def >=(that: String): Boolean = native - - def <(that: Dynamic): Boolean = native - def >(that: Dynamic): Boolean = native - def <=(that: Dynamic): Boolean = native - def >=(that: Dynamic): Boolean = native - - /* The result of (dyn && bool) and (dyn || bool) has, in theory, type - * (Dynamic v Boolean). This type cannot be expressed in Scala, but if it - * could, the operations one could apply on a (Dynamic v Boolean) would be - * the *intersection* of the operations one can apply on a Dynamic and on a - * Boolean. Since any operation can be applied on a Dynamic, this - * intersection is equal to the set of operations supported by Boolean. - * Hence the result type is restricted to Boolean. - */ - def &&(that: Boolean): Boolean = native - def ||(that: Boolean): Boolean = native - - def &&(that: Dynamic): Dynamic = native - def ||(that: Dynamic): Dynamic = native - - // Work around the annoying implicits in Predef in Scala 2.10. - def x: Dynamic = native - def x_=(value: Any): Unit = native -} - -/** Factory for dynamically typed JavaScript values. */ -object Dynamic { - /** Dynamic view of the global scope. */ - @inline def global: Dynamic = scala.scalajs.runtime.environmentInfo.global - - /** Instantiates a new object of a JavaScript class. */ - def newInstance(clazz: Dynamic)(args: Any*): Object with Dynamic = sys.error("stub") - - /** Creates a new object with a literal syntax. - * - * For example, - * js.Dynamic.literal(foo = 3, bar = "foobar") - * returns the JavaScript object - * {foo: 3, bar: "foobar"} - */ - object literal extends scala.Dynamic { - /** literal creation like this: - * js.Dynamic.literal(name1 = "value", name2 = "value") - */ - def applyDynamicNamed(name: java.lang.String)( - fields: (java.lang.String, Any)*): Object with Dynamic = sys.error("stub") - - /** literal creation like this: - * js.Dynamic.literal("name1" -> "value", "name2" -> "value") - * - * Note that this could be simply `def apply`, but this would make the - * applyDynamicNamed fail, since a call with named arguments would - * be routed to the `def apply`, rather than def dynamic version. - */ - def applyDynamic(name: java.lang.String)( - fields: (java.lang.String, Any)*): Object with Dynamic = sys.error("stub") - - } -} - -/** Base class of all JavaScript objects. */ -class Object extends Any { - def this(value: Any) = this() - - def toLocaleString(): String = native - def valueOf(): scala.Any = native - - /** Tests whether this object has the specified property as a direct property. - * - * Unlike [[js.Object.hasProperty]], this method does not check down the - * object's prototype chain. - * - * MDN - */ - def hasOwnProperty(v: String): Boolean = native - - /** Tests whether this object is in the prototype chain of another object. */ - def isPrototypeOf(v: Object): Boolean = native - - /** Tests whether the specified property in an object can be enumerated by a - * call to [[js.Object.properties]], with the exception of properties - * inherited through the prototype chain. If the object does not have the - * specified property, this method returns false. - * - * MDN - */ - def propertyIsEnumerable(v: String): Boolean = native -} - -/** The top-level `Object` JavaScript object. */ -object Object extends Object { - def apply(): Object = native - def apply(value: Any): Object = native - - /** Tests whether the object has a property on itself or in its prototype - * chain. This method is the equivalent of `p in o` in JavaScript. - */ - def hasProperty(o: Object, p: String): Boolean = sys.error("stub") - - /** - * The Object.getPrototypeOf() method returns the prototype (i.e. the - * internal [[Prototype]]) of the specified object. - * - * MDN - */ - def getPrototypeOf(o: Object): Object = native - - /** - * The Object.getOwnPropertyDescriptor() method returns a property descriptor - * for an own property (that is, one directly present on an object, not - * present by dint of being along an object's prototype chain) of a given object. - * - * MDN - */ - def getOwnPropertyDescriptor(o: Object, p: String): PropertyDescriptor = native - - /** - * Object.getOwnPropertyNames returns an array whose elements are strings - * corresponding to the enumerable and non-enumerable properties found - * directly upon obj. The ordering of the enumerable properties in the array - * is consistent with the ordering exposed by a for...in loop (or by Object.keys) - * over the properties of the object. The ordering of the non-enumerable - * properties in the array, and among the enumerable properties, is not defined. - * - * MDN - */ - def getOwnPropertyNames(o: Object): Array[String] = native - - /** - * The Object.create() method creates a new object with the specified - * prototype object and properties. - * - * MDN - */ - def create(o: Object, properties: Any): Object = native - def create(o: Object): Object = native - - /** - * The Object.defineProperty() method defines a new property directly on an - * object, or modifies an existing property on an object, and returns the - * object. - * - * This method allows precise addition to or modification of a property on an - * object. Normal property addition through assignment creates properties - * which show up during property enumeration (for...in loop or Object.keys method), - * whose values may be changed, and which may be deleted. This method allows - * these extra details to be changed from their defaults. - * - * Property descriptors present in objects come in two main flavors: data - * descriptors and accessor descriptors. A data descriptor is a property - * that has a value, which may or may not be writable. An accessor descriptor - * is a property described by a getter-setter pair of functions. A descriptor - * must be one of these two flavors; it cannot be both. - * - * MDN - */ - def defineProperty(o: Object, p: String, attributes: PropertyDescriptor): o.type = native - - /** - * The Object.defineProperties() method defines new or modifies existing - * properties directly on an object, returning the object. - * - * MDN - */ - def defineProperties(o: Object, properties: Any): o.type = native - - /** - * The Object.seal() method seals an object, preventing new properties from - * being added to it and marking all existing properties as non-configurable. - * Values of present properties can still be changed as long as they are - * writable. - * - * MDN - */ - def seal(o: Object): o.type = native - - /** - * The Object.freeze() method freezes an object: that is, prevents new properties - * from being added to it; prevents existing properties from being removed; - * and prevents existing properties, or their enumerability, configurability, - * or writability, from being changed. In essence the object is made effectively - * immutable. The method returns the object being frozen. - * - * MDN - */ - def freeze(o: Object): o.type = native - - /** - * The Object.preventExtensions() method prevents new properties from ever - * being added to an object (i.e. prevents future extensions to the object). - * - * An object is extensible if new properties can be added to it. preventExtensions - * marks an object as no longer extensible, so that it will never have - * properties beyond the ones it had at the time it was marked as non-extensible. - * Note that the properties of a non-extensible object, in general, may still be - * deleted. Attempting to add new properties to a non-extensible object will - * fail, either silently or by throwing a TypeError (most commonly, but not - * exclusively, when in strict mode). - * - * Object.preventExtensions only prevents addition of own properties. Properties - * can still be added to the object prototype. However, calling Object.preventExtensions - * on an object will also prevent extensions on its __proto__ property. - * - * MDN - */ - def preventExtensions(o: Object): o.type = native - - /** - * Returns true if the object is sealed, otherwise false. An object is sealed - * if it is not extensible and if all its properties are non-configurable and - * therefore not removable (but not necessarily non-writable). - * - * MDN - */ - def isSealed(o: Object): Boolean = native - - /** - * The Object.isFrozen() determines if an object is frozen. - * - * An object is frozen if and only if it is not extensible, all its properties - * are non-configurable, and all its data properties (that is, properties which - * are not accessor properties with getter or setter components) are non-writable. - * - * MDN - */ - def isFrozen(o: Object): Boolean = native - - /** - * Determines if extending of an object is allowed - * - * Objects are extensible by default: they can have new properties added to - * them, and (in engines that support __proto__ their __proto__ property) - * can be modified. An object can be marked as non-extensible using - * Object.preventExtensions, Object.seal, or Object.freeze - * - * MDN - */ - def isExtensible(o: Object): Boolean = native - - /** - * The Object.keys() method returns an array of a given object's own enumerable - * properties, in the same order as that provided by a for...in loop (the - * difference being that a for-in loop enumerates properties in the prototype - * chain as well). - * - * MDN - */ - def keys(o: Object): Array[String] = native - - /** Returns the names of all the enumerable properties of this object, - * including properties in its prototype chain. - * - * This method returns the same set of names that would be enumerated by - * a for-in loop in JavaScript, but not necessarily in the same order. - * - * If the underlying implementation guarantees an order for for-in loops, - * then this is guaranteed to be consistent with [[keys]], in the sense - * that the list returned by [[keys]] is a sublist of the list returned by - * this method (not just a subset). - */ - def properties(o: Any): Array[String] = sys.error("stub") -} - -package prim { - -/** Primitive JavaScript number. - * - * In most situations, you should not need this trait, and use - * [[scala.Double]] instead (or [[scala.Int]] where appropriate). - */ -sealed trait Number extends Any { - def unary_+(): Number = native - def unary_-(): Number = native - def unary_~(): Number = native - - def +(that: Number): Number = native - def -(that: Number): Number = native - def *(that: Number): Number = native - def /(that: Number): Number = native - def %(that: Number): Number = native - def <<(that: Number): Number = native - def >>(that: Number): Number = native - def >>>(that: Number): Number = native - def &(that: Number): Number = native - def |(that: Number): Number = native - def ^(that: Number): Number = native - - def +(that: Dynamic): Dynamic = native // could be a String if that is a String - def -(that: Dynamic): Number = native - def *(that: Dynamic): Number = native - def /(that: Dynamic): Number = native - def %(that: Dynamic): Number = native - def <<(that: Dynamic): Number = native - def >>(that: Dynamic): Number = native - def >>>(that: Dynamic): Number = native - def &(that: Dynamic): Number = native - def |(that: Dynamic): Number = native - def ^(that: Dynamic): Number = native - - def <(that: Number): Boolean = native - def >(that: Number): Boolean = native - def <=(that: Number): Boolean = native - def >=(that: Number): Boolean = native - - def <(that: Dynamic): Boolean = native - def >(that: Dynamic): Boolean = native - def <=(that: Dynamic): Boolean = native - def >=(that: Dynamic): Boolean = native - - def toString(radix: Number): String = native - - /** - * Returns a string representation of number that does not use exponential - * notation and has exactly digits digits after the decimal place. The number - * is rounded if necessary, and the fractional part is padded with zeros if - * necessary so that it has the specified length. If number is greater than - * 1e+21, this method simply calls Number.prototype.toString() and returns - * a string in exponential notation. - * - * MDN - */ - def toFixed(fractionDigits: Number): String = native - def toFixed(): String = native - - /** - * Returns a string representing a Number object in exponential notation with one - * digit before the decimal point, rounded to fractionDigits digits after the - * decimal point. If the fractionDigits argument is omitted, the number of - * digits after the decimal point defaults to the number of digits necessary - * to represent the value uniquely. - * - * If a number has more digits that requested by the fractionDigits parameter, - * the number is rounded to the nearest number represented by fractionDigits - * digits. See the discussion of rounding in the description of the toFixed() - * method, which also applies to toExponential(). - * - * MDN - */ - def toExponential(fractionDigits: Number): String = native - def toExponential(): String = native - - /** - * Returns a string representing a Number object in fixed-point or exponential - * notation rounded to precision significant digits. See the discussion of - * rounding in the description of the Number.prototype.toFixed() method, which - * also applies to toPrecision. - * - * If the precision argument is omitted, behaves as Number.prototype.toString(). - * If it is a non-integer value, it is rounded to the nearest integer. - * - * MDN - */ - def toPrecision(precision: Number): String = native - def toPrecision(): String = native -} - -/** The top-level `Number` JavaScript object */ -object Number extends Object { - /** - * The Number.MAX_VALUE property represents the maximum numeric value - * representable in JavaScript. - * - * The MAX_VALUE property has a value of approximately 1.79E+308. Values - * larger than MAX_VALUE are represented as "Infinity". - * - * MDN - */ - val MAX_VALUE: Double = native - /** - * The Number.MIN_VALUE property represents the smallest positive numeric - * value representable in JavaScript. - * - * The MIN_VALUE property is the number closest to 0, not the most negative - * number, that JavaScript can represent. - * - * MIN_VALUE has a value of approximately 5e-324. Values smaller than MIN_VALUE - * ("underflow values") are converted to 0. - * - * MDN - */ - val MIN_VALUE: Double = native - /** - * The Number.NaN property represents Not-A-Number. Equivalent of NaN. - * - * MDN - */ - val NaN: Double = native - - /** - * The Number.NEGATIVE_INFINITY property represents the negative Infinity value. - * - * MDN - */ - val NEGATIVE_INFINITY: Double = native - /** - * The Number.POSITIVE_INFINITY property represents the positive Infinity value. - * - * MDN - */ - val POSITIVE_INFINITY: Double = native -} - -/** Primitive JavaScript boolean. - * - * In most situations, you should not need this trait, and use - * [[scala.Boolean]] instead. - */ -sealed trait Boolean extends Any { - def unary_!(): scala.Boolean = native - - def &&(that: Boolean): Boolean = native - def ||(that: Boolean): Boolean = native - - // See the comment in `Dynamic` for the rationale of returning Boolean here. - def &&(that: Dynamic): Boolean = native - def ||(that: Dynamic): Boolean = native -} - -/** The top-level `Boolean` JavaScript object. */ -object Boolean extends Object - -/** Primitive JavaScript string. - * - * In most situations, you should not need this trait, and use - * [[java.lang.String]] instead. - */ -sealed trait String extends Any { - def +(that: String): String = native - def +(that: Any): String = native - def +(that: Dynamic): String = native - - def < (that: String): Boolean = native - def < (that: Dynamic): Boolean = native - - def > (that: String): Boolean = native - def > (that: Dynamic): Boolean = native - - def <=(that: String): Boolean = native - def <=(that: Dynamic): Boolean = native - - def >=(that: String): Boolean = native - def >=(that: Dynamic): Boolean = native - - /** - * This property returns the number of code units in the string. UTF-16, - * the string format used by JavaScript, uses a single 16-bit code unit to - * represent the most common characters, but needs to use two code units for - * less commonly-used characters, so it's possible for the value returned by - * length to not match the actual number of characters in the string. - * - * For an empty string, length is 0. - * - * MDN - */ - val length: Number = native - - /** - * The chartAt() method returns the specified character from a string. - * - * Characters in a string are indexed from left to right. The index of the - * first character is 0, and the index of the last character in a string - * called stringName is stringName.length - 1. If the index you supply is out - * of range, JavaScript returns an empty string. - * - * MDN - */ - def charAt(pos: Number): String = native - - /** - * The charCodeAt() method returns the numeric Unicode value of the character - * at the given index (except for unicode codepoints > 0x10000). - * - * MDN - */ - def charCodeAt(index: Number): Number = native - - /** - * concat combines the text from one or more strings and returns a new string. - * Changes to the text in one string do not affect the other string. - * MDN - */ - def concat(strings: String*): String = native - - /** - * Returns the index within the calling String object of the first occurrence - * of the specified value, starting the search at fromIndex, - * - * returns -1 if the value is not found. - * - * MDN - */ - def indexOf(searchString: String, position: Number): Number = native - def indexOf(searchString: String): Number = native - - /** - * Returns the index within the calling String object of the last occurrence - * of the specified value, or -1 if not found. The calling string is searched - * backward, starting at fromIndex. - * - * MDN - */ - def lastIndexOf(searchString: String, position: Number): Number = native - def lastIndexOf(searchString: String): Number = native - - /** - * Returns a number indicating whether a reference string comes before or - * after or is the same as the given string in sort order. The new locales - * and options arguments let applications specify the language whose sort - * order should be used and customize the behavior of the function. In older - * implementations, which ignore the locales and options arguments, the locale - * and sort order used are entirely implementation dependent. - * - * MDN - */ - def localeCompare(that: String): Number = native - - /** - * Used to retrieve the matches when matching a string against a regular - * expression. - * - * If the regular expression does not include the g flag, returns the same - * result as regexp.exec(string). The returned Array has an extra input - * property, which contains the original string that was parsed. In addition, - * it has an index property, which represents the zero-based index of the - * match in the string. - * - * If the regular expression includes the g flag, the method returns an Array - * containing all matches. If there were no matches, the method returns null. - * - * MDN - */ - def `match`(regexp: String): Array[String] = native - def `match`(regexp: RegExp): Array[String] = native - - /** - * Returns a new string with some or all matches of a pattern replaced by a - * replacement. The pattern can be a string or a RegExp, and the replacement - * can be a string or a function to be called for each match. - * - * This method does not change the String object it is called on. It simply - * returns a new string. - * - * To perform a global search and replace, either include the g switch in the - * regular expression or if the first parameter is a string, include g in the - * flags parameter. - * - * MDN - */ - def replace(searchValue: String, replaceValue: String): String = native - def replace(searchValue: String, replaceValue: Any): String = native - def replace(searchValue: RegExp, replaceValue: String): String = native - def replace(searchValue: RegExp, replaceValue: Any): String = native - - /** - * If successful, search returns the index of the regular expression inside - * the string. Otherwise, it returns -1. - * - * When you want to know whether a pattern is found in a string use search - * (similar to the regular expression test method); for more information - * (but slower execution) use match (similar to the regular expression exec - * method). - * - * MDN - */ - def search(regexp: String): Number = native - def search(regexp: RegExp): Number = native - - /** - * slice extracts the text from one string and returns a new string. Changes - * to the text in one string do not affect the other string. - * - * slice extracts up to but not including endSlice. string.slice(1,4) extracts - * the second character through the fourth character (characters indexed 1, 2, - * and 3). - * - * As an example, string.slice(2,-1) extracts the third character through the - * second to last character in the string. - * - * MDN - */ - def slice(start: Number, end: Number): String = native - def slice(start: Number): String = native - - /** - * Splits a String object into an array of strings by separating the string - * into substrings. - * - * When found, separator is removed from the string and the substrings are - * returned in an array. If separator is omitted, the array contains one - * element consisting of the entire string. If separator is an empty string, - * string is converted to an array of characters. - * - * If separator is a regular expression that contains capturing parentheses, - * then each time separator is matched, the results (including any undefined - * results) of the capturing parentheses are spliced into the output array. - * However, not all browsers support this capability. - * - * Note: When the string is empty, split returns an array containing one - * empty string, rather than an empty array. - * - * MDN - */ - def split(separator: String, limit: Number): Array[String] = native - def split(separator: String): Array[String] = native - def split(separator: RegExp, limit: Number): Array[String] = native - def split(separator: RegExp): Array[String] = native - - /** - * Returns a subset of a string between one index and another, or through - * the end of the string. - * - * MDN - */ - def substring(start: Number, end: Number): String = native - def substring(start: Number): String = native - - /** - * Returns the calling string value converted to lowercase. - * - * MDN - */ - def toLowerCase(): String = native - - /** - * The toLocaleLowerCase method returns the value of the string converted to - * lower case according to any locale-specific case mappings. toLocaleLowerCase - * does not affect the value of the string itself. In most cases, this will - * produce the same result as toLowerCase(), but for some locales, such as - * Turkish, whose case mappings do not follow the default case mappings in Unicode, - * there may be a different result. - * - * MDN - */ - def toLocaleLowerCase(): String = native - - /** - * Returns the calling string value converted to uppercase. - * - * MDN - */ - def toUpperCase(): String = native - - /** - * The toLocaleUpperCase method returns the value of the string converted to - * upper case according to any locale-specific case mappings. toLocaleUpperCase - * does not affect the value of the string itself. In most cases, this will - * produce the same result as toUpperCase(), but for some locales, such as - * Turkish, whose case mappings do not follow the default case mappings in Unicode, - * there may be a different result. - * - * MDN - */ - def toLocaleUpperCase(): String = native - - /** - * Removes whitespace from both ends of the string. - * - * MDN - */ - def trim(): String = native -} - -/** The top-level `String` JavaScript object. */ -object String extends Object { - def fromCharCode(codes: Int*): java.lang.String = native -} - -/** Primitive JavaScript undefined value. - * - * In most situations, you should not need this trait, and use - * [[scala.Unit]] instead. - */ -sealed trait Undefined extends Any - -} |