public JsNode VisitNamedExpression(NamedExpression node) { var name = new JsJsonMember { Name = node.Name }; if (name.Name.IsNullOrEmpty()) { throw new NotImplementedException(); //if (d.expression.e == cs_node.n_simple_name) // name.Name = ((CsSimpleName)d.expression).identifier.identifier; //else if (d.expression.e == cs_node.n_primary_expression_member_access) // name.Name = ((CsPrimaryExpressionMemberAccess)d.expression).identifier.identifier; } var value = VisitExpression(node.Expression); var ce = node.GetParentType(); var nativeJson = Sk.UseNativeJsons(ce.GetDefinitionOrArrayType()); if (!nativeJson) { name.Name = "get_" + name.Name; value = new JsFunction { Block = new JsBlock { Statements = new List <JsStatement> { new JsReturnStatement { Expression = value } } } }; } return(new JsJsonNameValue { Name = name, Value = value }); }
public JsFunctionDelegate( IJintVisitor visitor, JsFunction function, JsDictionaryObject that, Type delegateType) { if (visitor == null) { throw new ArgumentNullException(nameof(visitor)); } if (function == null) { throw new ArgumentNullException(nameof(function)); } if (delegateType == null) { throw new ArgumentNullException(nameof(delegateType)); } if (!typeof(Delegate).IsAssignableFrom(delegateType)) { throw new ArgumentException("A delegate type is required", nameof(delegateType)); } this.m_visitor = visitor; this.m_function = function; this.m_delegateType = delegateType; this.m_that = that; this.m_marshaller = visitor.Global.Marshaller; }
private object MarshalJsFunctionHelper(JsFunction func, Type delegateType) { return((object)new JsFunctionDelegate((IJintVisitor) new ExecutionVisitor(this.m_global, new JsScope((JsDictionaryObject)this.m_global)) { PermissionSet = ((ExecutionVisitor)this.m_global.Visitor).PermissionSet }, func, (JsDictionaryObject)JsNull.Instance, delegateType).GetDelegate()); }
public JsNode VisitLambdaResolveResult(LambdaResolveResult res) { //var prmTypes = res.Parameters.Select(t => t.Type).ToArray(); //var retType = res.GetInferredReturnType(prmTypes); //var conv = res.IsValid(prmTypes, retType, CSharpConversions.Get(Project.Compilation)); //return Visit(conv); var func = new JsFunction { Parameters = res.Parameters.Select(t => JsIdentifier(t.Name)).ToList() }; var body = res.Body; JsNode body2; var info = res.GetInfo(); if (body.GetType() == typeof(ResolveResult) && body.Type.IsVoid()) { var x = res.GetType().GetProperty("BodyExpression", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic).GetValue(res, null); var astNode = (AstNode)x; body2 = Visit(astNode); } else { body2 = Visit(res.Body); } var currentMember = res.GetCurrentMember(); var delType = info.ConversionTargetType; if (body2 is JsExpression) { var delMethod = delType.GetDelegateInvokeMethod(); JsStatement st = new JsReturnStatement { Expression = (JsExpression)body2 }; if (delMethod != null && delMethod.ReturnType.IsVoid()) { st = new JsExpressionStatement { Expression = (JsExpression)body2 } } ; func.Block = new JsBlock { Statements = new List <JsStatement> { st } }; } else if (body2 is JsBlock) { func.Block = (JsBlock)body2; } if (delType == null || currentMember == null) { Log.Warn(res.GetFirstNode(), "Cannot resolve delegate type / parent method"); return(func); } else { return(CreateJsDelegateIfNeeded(func, currentMember, delType, true)); } }
public object CallFunction(JsFunction function, params object[] args) { try { visitor.ExecuteFunction(function, null, JsClr.ConvertParametersBack(visitor, args)); return(JsClr.ConvertParameter(visitor.Returned)); } catch (TargetInvocationException e) { string message = String.Format("{0}\n{1}: {2} in {3}" , e.InnerException.Message, moduleName, CurrentString, CurrentLine); throw new BitMobile.Utilities.Exceptions.JSException(message, e); } catch (BitMobile.Utilities.Exceptions.JsGlobalException e) { string message = String.Format("Error occured in script function:\n{0}\n{1}: {2} in {3}" , e.Message, moduleName, CurrentString, CurrentLine); throw new BitMobile.Utilities.Exceptions.JSException(message, e); } catch (Exception e) { string message = String.Format("{0}\n{1}: {2} in {3}" , e.Message, moduleName, CurrentString, CurrentLine); throw new BitMobile.Utilities.Exceptions.JSException(message, e); } }
public JavaScriptHandle(JsContext jsc, string init, ICollection <int> providers, DictionaryCache cache) { this.jsc = jsc; this.cache = cache; jsc.sync(js => { js.name("limax.js").eval(limax.script.codes.js.limax); js.name("cache").eval("var cache=<0>", cache); js.name("initscript").eval(init); if (providers == null || providers.Count == 0) { foreach (object pvid in (JsArray)js.eval("providers")) { this.providers.Add((int)pvid); } } else { foreach (var pvid in providers) { this.providers.Add(pvid); } } this.instance = (JsFunction)js.name("").eval("limax"); }); }
public override JsNode _VisitDelegate(ITypeDefinition ce) { var CurrentType = new JsClrType { Kind = JsClrTypeKind.Delegate }; CurrentType.fullname = GetJsTypeName(ce); //Generate constructor var genericParams = new List <ITypeParameter>(ce.GetGenericArguments()); var func = new JsFunction(); func.Parameters = genericParams.Select(t => t.Name).ToList(); func.Parameters.Add("obj"); func.Parameters.Add("func"); func.Block = Js.Block(); foreach (var ga in genericParams) { func.Block.Add(Js.This().Member(ga.Name).Assign(Js.Member(ga.Name)).Statement()); } func.Block.Add(Js.Members("System.MulticastDelegate.ctor.call").Invoke(Js.This(), Js.Member("obj"), Js.Member("func")).Statement()); CurrentType.GetDefinition(false)["ctor"] = func; return(OnAfterExportType(ce, CurrentType)); //return func; //FullName',{ ShortName:function(T1,T2,T3,...,obj,func){this.T1=T1;....;this.construct(obj,func);}, })"); }
public object CallFunction(JsFunction function, params object[] args) { Visitor.ExecuteFunction(function, null, args.Select(x => Visitor.Global.Marshaller.MarshalClrValue <object>(x)).ToArray() //Array.ConvertAll<object,JsInstance>( args, x => Visitor.Global.Marshaller.MarshalClrValue<object>(x) ) ); return(Visitor.Global.Marshaller.MarshalJsValue <object>(Visitor.Returned)); }
public static void CreateInstanceImpl(JsClass klass) { var func = new JsFunction(null); func.Body.Add(klass.Type.New().Return()); klass.ExtendPrototype(func, "CreateInstance"); }
public void AddSamples(SampleArray samples) { var uint8 = new Uint8Array(samples.Buffer); JsFunction fromCharCode = JsCode("String.fromCharCode").As <JsFunction>(); var b64 = window.btoa(fromCharCode.apply(null, uint8.As <object[]>()).As <string>()); document.getElementById(_swfId).As <IFlashSynthOutput>().AlphaSynthAddSamples(b64); }
public static void ExtendPrototype(this JsClass klass, JsFunction func, string name) { var type = klass.Type; var typeName = type.IsString() ? "String" : type.JsFullName(); var fullName = typeName + ".prototype." + name; klass.Add(new JsGeneratedMethod(fullName, func)); }
public virtual void Visit(JsFunction node) { DefaultVisit(node); foreach (var parameter in node.Parameters) { VisitDeclaration(parameter); } node.Body.Accept(this); }
object MarshalJsFunctionHelper(JsFunction func, Type delegateType) { // create independent visitor ExecutionVisitor visitor = new ExecutionVisitor(m_global, new JsScope((JsObject)m_global)); visitor.PermissionSet = ((ExecutionVisitor)m_global.Visitor).PermissionSet; JsFunctionDelegate wrapper = new JsFunctionDelegate(visitor, func, JsNull.Instance, delegateType); return(wrapper.GetDelegate()); }
public virtual JsNode ExportConstructor(IMethod ctor) { var ctorName = SkJs.GetEntityJsName(ctor); var func = new JsFunction { Parameters = new List <string>() }; func.Block = ExportConstructorBody(ctor); ExportConstructorParameters(ctor, func); return(func); }
public JsFunction DefineFunctionMessage(MethodBase method) { JsFunction function = new JsFunction(method); DefineFunctionMessage msgDef = new DefineFunctionMessage { Name = function.Name, Parameters = function.Parameters, Body = function.Body }; SendMessage(msgDef); return function; }
public virtual JsNode Visit(JsFunction node) { return(DefaultVisit(node, x => { for (var i = 0; i < x.Parameters.Count; i++) { x.Parameters[i] = (IJsDeclaration)VisitDeclaration(x.Parameters[i]); } x.Body = (JsBlockStatement)x.Body.Accept(this); return x; })); }
protected JsFunction ApplyYield(JsFunction func) { if (AstNodeConverter.SupportClrYield && func.Block.Descendants().OfType <JsYieldStatement>().FirstOrDefault() != null) { var yielder = new YieldRefactorer { BeforeFunction = func }; yielder.Process(); return(yielder.AfterFunction); } return(func); }
private string PromiseRequire(JsFunction func) { return (@"function(extraArgs){ return new Promise(function(resolve){ require(['{moduleNames}'], function({moduleVars}){ {moduleVars}.{functionName}({arguments}).then(function(args) { resolve(args); }); }); }); }".Replace("{moduleNames}", func.Module.Name) .Replace("{moduleVars}", JsFunction.VarName(func.Module)) .Replace("{functionName}", func.FunctionName) .Replace("{arguments}", func.Arguments.ToString(a => a == ClientConstructorManager.ExtraJsonParams ? "extraArgs" : JsonConvert.SerializeObject(a, func.JsonSerializerSettings), ", "))); }
public static void OnLoad() { jQuery.ajax(new AjaxSettings { url = "Handler.ashx", dataType = "text", success = (js, b, cc) => { var func = new JsFunction(js.As <JsString>()); var x = func.call(); var c = x.As <Contact>(); HtmlContext.alert(c.GetType().FullName + "," + c.Name); } }); }
public static void OnLoad() { jQuery.ajax(new AjaxSettings { url = "Handler.ashx", dataType = "text", success = (js, b, cc) => { var func = new JsFunction(js.As<JsString>()); var x = func.call(); var c = x.As<Contact>(); HtmlContext.alert(c.GetType().FullName+","+c.Name); } }); }
private static JsFunction GetImpl(MethodContext context, IEnumerable <KeyValuePair <Func <IMethod, bool>, Action <MethodContext, JsBlock> > > list) { var method = context.Method; foreach (var pair in list) { if (pair.Key(method)) { var parameters = method.Parameters.Select(x => x.Name).ToArray(); var func = new JsFunction(null, parameters); pair.Value(context, func.Body); return(func); } } return(null); }
public virtual JsNode ExportMethod(IMethod me) { var jma = Sk.GetJsMethodAttribute(me); if (jma != null && jma.GlobalCode) { var block = ExportMethodBody(me); return(new JsUnit { Statements = block.Statements }); } var func = new JsFunction(); func.Parameters = ExportMethodParameters(me); func.Name = SkJs.GetEntityJsName(me); func.Block = ExportMethodBody(me); func = ApplyYield(func); return(func); }
public void Process() { AfterFunction = BeforeFunction; SetParents(BeforeFunction.Block); foreach (var me in BeforeFunction.Block.Descendants <JsMemberExpression>().ToList()) { if (me.PreviousMember == null && me.NodeType == JsNodeType.MemberExpression) { me.PreviousMember = Js.This(); } } BeginNewStep(); ProcessStatement(BeforeFunction.Block); BeforeFunction.Block.Statements.Clear(); var func = new JsFunction { Block = new JsBlock { Statements = new List <JsStatement>() } }; var i = 0; func.Block.Statements.Add(Js.Var("result").Statement()); var stSwitch = Js.Switch(_state()); var lastStep = Js.Block().Add(_state().Assign(Js.Value(Steps.Count)).Statement()).Add(new JsBreakStatement()); Steps.Add(new YieldStep { Statements = { lastStep } }); foreach (var step in Steps) { stSwitch.Case(Js.Value(i), step.Statements); i++; } func.Block.Statements.Add(stSwitch); func.Block.Statements.Add(Js.Member("result").Assign(Js.Value(false)).Statement()); func.Block.Statements.Add(Js.Return(Js.Member("result"))); BeforeFunction.Block.Statements.Add(Js.Return(Js.New(Js.Member("CustomEnumerable"), func))); return; }
public JavaScriptHandle(JsContext jsc, string init, ICollection <int> providers, DictionaryCache cache, TunnelReceivier ontunnel) { this.jsc = jsc; this.cache = cache != null ? cache : new SimpleDictionaryCache(); TunnelReceivier _ontunnel = (providerid, label, data) => { if (providerid == AuanyService.providerId) { if (lmkDataReceiver != null) { lmkDataReceiver.onLmkData(data, () => tunnel(AuanyService.providerId, -1, "")); } } else if (ontunnel != null) { ontunnel(providerid, label, data); } }; jsc.sync(js => { js.name("limax.js").eval(limax.script.codes.js.limax); js.name("cache").eval("var cache=<0>", this.cache); js.name("ontunnel").eval("var ontunnel=<0>", _ontunnel); js.name("initscript").eval(init); if (providers == null || providers.Count == 0) { foreach (object pvid in (JsArray)js.eval("providers")) { this.providers.Add((int)pvid); } } else { foreach (var pvid in providers) { this.providers.Add(pvid); } } this.instance = (JsFunction)js.name("").eval("limax"); }); }
void VerifyConstructors() { if (_Constructors == null) { VerifyMethods(); _Constructors = new JsExtendedArray(); for (int i = 0; i < _JsType.ctors.As <JsArray>().length; i++) { JsObject ctorMeta = _JsType.ctors[i.As <string>()].As <JsObject>(); string ctorName = ctorMeta["name"].As <string>(); JsArray <string> ctorParams = ctorMeta["parameters"].As <JsArray <string> >(); JsFunction ctorFunc = ctorMeta["_type"].As <JsObject>()[ctorName].As <JsFunction>(); var method = new JsImplConstructorInfo(ctorName, ctorFunc, ctorParams); method._DeclaringType = this; //method.JsName = funcName; //method.JsFunction = func; _Constructors.push(method); } } }
JsNode CreateJsDelegateIfNeeded(JsFunction func, IMember currentMember, IType delType, bool isAnonymous) { if (currentMember != null && !currentMember.IsStatic && !UseNativeFunctions(delType) && !Sk.ForceDelegatesAsNativeFunctions(currentMember)) { var instanceContext = new JsThis(); JsExpression wrapper; if (isAnonymous) { wrapper = CreateAnonymousJsDelegate(instanceContext, func); } else { wrapper = CreateJsDelegate(instanceContext, func); } return(wrapper); } else { return(func); } }
public override void VisitFunction(JsFunction node) { output.Append("function"); if (node.Name != null) { output.Append(" "); output.Append(node.Name); } output.Append("("); for (var i = 0; i < node.Parameters.Count; i++) { var argument = node.Parameters[i]; output.Append(argument.Name); if (i < node.Parameters.Count - 1) { output.Append(", "); } } output.Append(") "); node.Body.Accept(this); }
public object CallFunction(JsFunction function, params object[] args) { visitor.ExecuteFunction(function, null, Array.ConvertAll <object, JsInstance>(args, (x) => { TypeCode t = Type.GetTypeCode(x.GetType()); switch (t) { case TypeCode.Boolean: return(visitor.Global.BooleanClass.New((bool)x)); case TypeCode.Char: case TypeCode.String: case TypeCode.Object: return(visitor.Global.StringClass.New(x.ToString())); case TypeCode.DateTime: return(visitor.Global.DateClass.New((DateTime)x)); case TypeCode.Byte: case TypeCode.Int16: case TypeCode.Int32: case TypeCode.Int64: case TypeCode.SByte: case TypeCode.UInt16: case TypeCode.UInt32: case TypeCode.UInt64: case TypeCode.Decimal: case TypeCode.Double: case TypeCode.Single: return(visitor.Global.NumberClass.New( Convert.ToDouble(x))); case TypeCode.DBNull: case TypeCode.Empty: return(JsNull.Instance); } throw new NotSupportedException(); })); return(visitor.Returned); }
/// <summary> /// /// </summary> /// <param name="e"></param> protected async override void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); try { var js = new FileInfo(@"test.js"); using (var runtime = JsRuntime.Create()) { runtime.AllocatingMemory += this.Runtime_MemoryEvent; runtime.CollectingGarbage += this.Runtime_CollectingGarbage; using (runtime.CreateContext().Use(true)) { try { var obj = JsExternalObject.Create(this); obj.ExternalData = 12; obj.ExternalData = 100; JsContext.StartDebugging(); var func = JsFunction.Create(saf); var console = Opportunity.ChakraBridge.WinRT.Browser.Console.GetOrCreate(); console.Logging += Con_Logging; var c2 = Opportunity.ChakraBridge.WinRT.Browser.Console.GetOrCreate(); JsValue.GlobalObject["func"] = func; JsContext.RunScript("console.log(1,'2',{});func(1,'2',{});new func();", js.Name); } catch (Exception) { var error = JsContext.LastError; } } } } catch (Exception) { } }
public static JsFunction GetDelegate(object obj, JsFunction func) { var target = obj.As <JsCompilerObject>(); if (target == null) { return(func); } if (JsContext.@typeof(func) == "string") { func = target.As <JsObject>()[func.As <JsString>()].As <JsFunction>(); } var cache = target.__delegateCache; if (cache == null) { cache = new JsObject <JsDelegateFunction>(); target.__delegateCache = cache; } var key = JsCompiler.GetHashKey(func); var del = cache[key]; if (del == null) { del = new JsNativeFunc <object>(delegate() { var del2 = JsContext.arguments.callee.As <JsDelegateFunction>(); return(del2.func.apply(del.target, JsContext.arguments.As <object[]>())); }).As <JsDelegateFunction>(); del.func = func; del.target = target; del.isDelegate = true; cache[key] = del; } return(del); }
public object CallFunction(JsFunction function, params object[] args) { visitor.ExecuteFunction(function, null, Array.ConvertAll<object,JsInstance>( args, x => visitor.Global.Marshaller.MarshalClrValue<object>(x) )); return visitor.Global.Marshaller.MarshalJsValue<object>(visitor.Returned); }
public JintEngine SetFunction(string name, JsFunction function) { visitor.GlobalScope[name] = function; return this; }
///// <summary> ///// Could be used inside event handler to figure out actual name of the eve ///// </summary> ///// <param name="subname">subname of the event</param> ///// <returns>name of the event, if subname is not specified</returns> //public JsString nt(JsString subname) { return null; } /// <summary> /// Removes given function from the list of event listeners assigned to given name. /// </summary> /// <param name="name">name of the event, dot (.) or slash (/) separated, with optional wildcard</param> /// <param name="f">event handler function</param> public void off(JsString name, JsFunction f) { }
/// <summary> /// set draw function /// </summary> /// <param name="drawFunc">drawing function</param> public void setDrawFunc(JsFunction drawFunc) { }
public object CallFunction(JsFunction function, params object[] args) { visitor.ExecuteFunction(function, null, Array.ConvertAll<object,JsInstance>(args, (x) => { TypeCode t = Type.GetTypeCode(x.GetType()); switch (t) { case TypeCode.Boolean: return visitor.Global.BooleanClass.New((bool)x); case TypeCode.Char: case TypeCode.String: case TypeCode.Object: return visitor.Global.StringClass.New(x.ToString()); case TypeCode.DateTime: return visitor.Global.DateClass.New((DateTime)x); case TypeCode.Byte: case TypeCode.Int16: case TypeCode.Int32: case TypeCode.Int64: case TypeCode.SByte: case TypeCode.UInt16: case TypeCode.UInt32: case TypeCode.UInt64: case TypeCode.Decimal: case TypeCode.Double: case TypeCode.Single: return visitor.Global.NumberClass.New( Convert.ToDouble(x)); case TypeCode.DBNull: case TypeCode.Empty: return JsNull.Instance; } throw new NotSupportedException(); })); return visitor.Returned; }
internal static object NewByFunc(JsFunction ctor) { return null; }
public extern JsString replace(JsRegExp regexp, JsFunction replaceWith);
/// <summary> /// Returns the current position within an audio file. /// </summary> /// <param name="mediaSuccess">The callback that is called with the current position in seconds.</param> /// <example> /// usage /// <code> /// // Audio player /// // ///var my_media = new Media(src, onSuccess, onError); /// // Update media position every second ///var mediaTimer = setInterval(function() { /// // get media position /// my_media.getCurrentPosition( /// // success callback /// function(position) { /// if (position > -1) { /// console.log((position) + " sec"); /// } /// }, /// // error callback /// function(e) { /// console.log("Error getting pos=" + e); /// } /// ); ///}, 1000); /// </code> /// </example> public void getCurrentPosition(JsFunction mediaSuccess) { }
internal static object NewByFuncArgs(JsFunction ctor, JsArray args) { return(null); }
public static JsFunction FunctionInline(JsList parameters, JsMultiLine commands) { JsFunction f = new JsFunction(parameters, commands); f.MultiLine = false; return f; }
/// <summary> /// Matches when the observable sequence has an available value and projects the value. /// </summary> public Plan Then(JsFunction selector) { return default(Plan); }
public virtual AbstractBehavior createExternalBehavior( HtmlElement element, JsString behaviorClassName, JsFunction constructorFunction ) { return null; }
/// <summary> /// Binds given event handler with a given name to only run once then unbind itself. /// eve.once("login", f); /// eve("login"); // triggers f /// eve("login"); // no listeners /// Use eve to trigger the listener. /// </summary> /// <param name="name">name of the event, dot (.) or slash (/) separated, with optional wildcards</param> /// <param name="f">event handler function</param> /// <returns>same return function as eve.on</returns> public JsFunction once(JsString name, JsFunction f) { return null; }
public JsFunction CreateFunction(JsFormat format, JsMultiLine commands) { JsFunction f = new JsFunction(this, commands); f.SetFormat(format); return f; }
[JsMethod(Code="if(prms==null || prms.length==0) return new jsCtor(); return new jsCtor(prms[0], prms[1], prms[2], prms[3], prms[4], prms[5], prms[6], prms[7], prms[8]);")]//TODO: switch by prm number internal static object ApplyNew(JsFunction jsCtor, JsArray prms) { throw new NotImplementedException(); }
internal static JsDelegateFunction CreateClrDelegate(JsType type, JsArray<JsType> genericArgs, object target, JsFunction func) { return JsTypeHelper.GetDelegate(target, func).As<JsDelegateFunction>(); //TODO: support delegate.getType() }
/// <summary> /// set after frame event handler /// </summary> /// <param name="index">frame index</param> /// <param name="func">function to be executed after frame has been drawn</param> public void afterFrame(JsArray index, JsFunction func) { }
/// <summary> /// Returns the current position within an audio file. /// </summary> /// <param name="mediaSuccess">The callback that is called with the current position in seconds.</param> /// <param name="mediaError">The callback that is called if there was an error.</param> /// <example> /// usage /// <code> /// // Audio player /// // ///var my_media = new Media(src, onSuccess, onError); /// // Update media position every second ///var mediaTimer = setInterval(function() { /// // get media position /// my_media.getCurrentPosition( /// // success callback /// function(position) { /// if (position > -1) { /// console.log((position) + " sec"); /// } /// }, /// // error callback /// function(e) { /// console.log("Error getting pos=" + e); /// } /// ); ///}, 1000); /// </code> /// </example> public void getCurrentPosition(JsFunction mediaSuccess, MediaError mediaError) { }
/// <summary> /// sets onFrameFunc for animation /// </summary> /// <param name="func"></param> public void onFrame(JsFunction func) { }
internal static object NewByFuncArgs(JsFunction ctor, JsArray args) { return null; }
/// <summary> /// bind events to the node. KineticJS supports mouseover, mousemove,mouseout, mousedown, mouseup, click, dblclick, touchstart, touchmove,touchend, tap, dbltap, dragstart, dragmove, and dragend. Pass in a stringof event types delimmited by a space to bind multiple events at oncesuch as 'mousedown mouseup mousemove'. /// include a namespace to bind anevent by name such as 'click.foobar'. /// </summary> /// <param name="typesStr"></param> /// <param name="handler"></param> public void on(JsString typesStr, JsFunction handler) { }
private void AssertJsFunction(JsFunction function, string name, string parameters, string body) { Assert.AreEqual(name, function.Name); Assert.AreEqual(parameters, function.Parameters); Assert.AreEqual(body, function.Body); }
/// <summary> /// Executes given function for each element in the set. /// If function returns false it will stop loop running. /// </summary> /// <param name="callback">function to run</param> /// <param name="thisArg">context object for the callback</param> /// <returns>Set object</returns> public object forEach(JsFunction callback, object thisArg) { return null; }
internal static object NewByFunc(JsFunction ctor) { return(null); }
private void RunTest(MethodBase method, string name, string parameters, string body) { var function = new JsFunction(method); AssertJsFunction(function, name, parameters, body); }
public static JsFunction GetDelegate(object obj, JsFunction func) { var target = obj.As<JsCompilerObject>(); if (target == null) return func; if (JsContext.@typeof(func) == "string") func = target.As<JsObject>()[func.As<JsString>()].As<JsFunction>(); var cache = target.__delegateCache; if (cache == null) { cache = new JsObject<JsDelegateFunction>(); target.__delegateCache = cache; } var key = JsCompiler.GetHashKey(func); var del = cache[key]; if (del == null) { del = new JsNativeFunc<object>(delegate() { var del2 = JsContext.arguments.callee.As<JsDelegateFunction>(); return del2.func.apply(del.target, JsContext.arguments.As<object[]>()); }).As<JsDelegateFunction>(); del.func = func; del.target = target; del.isDelegate = true; cache[key] = del; } return del; }
public static void tap(this jQueryFn jqfn, JsFunction fn) { throw new NotImplementedException(); }
public static void enable(string eventName, object target, JsFunction isEnabled) { }
public extern JsString replace(JsString substring, JsFunction replaceWith);