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, 872 insertions, 0 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 new file mode 100644 index 0000000..1a3d88c --- /dev/null +++ b/examples/scala-js/library/src/main/scala/scala/scalajs/js/Primitives.scala @@ -0,0 +1,872 @@ +/* __ *\ +** ________ ___ / / ___ __ ____ 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 + +} |