@lovelace_lol/polymer 0.0.1

package/src/polymer/animation/runtime.cljs

@@ -0,0 +1,137 @@
+(ns polymer.animation.runtime
+  (:require [polymer.animation.domain :as domain]))
+
+;; Runtime functions are Animation's side-effect boundary. Everything here is
+;; allowed to touch JavaScript handles or an injected animation engine; planner,
+;; scheduler decision logic, and domain transforms are not.
+
+(defn js-callable? [value]
+  (= "function" (goog/typeOf value)))
+
+(defn js-method [target name]
+  (when target
+    (let [method (aget target name)]
+      (when (js-callable? method)
+        method))))
+
+(defn call-js [target name & args]
+  (when-let [method (js-method target name)]
+    (.apply method target (to-array args))))
+
+(defn play-built-handle! [handle]
+  (when-let [play (js-method handle "play")]
+    (.call play handle))
+  handle)
+
+(defn engine->runtime [engine]
+  ;; Some callers still pass a larger engine object. Animation adapts it once
+  ;; into the smaller runtime API it needs, keeping that dependency at this
+  ;; boundary instead of leaking engine calls into other agencies.
+  (let [runtime #js {:buildClip (fn [clip-name curves options]
+                                  (call-js engine "buildClip" clip-name curves options))
+                     :playSnippet (fn [clip-name curves options]
+                                    (or
+                                     (call-js engine "playSnippet" #js {:name clip-name :curves curves} options)
+                                     (let [handle (call-js engine "buildClip" clip-name curves options)]
+                                       (play-built-handle! handle))))
+                     :updateClipParams (fn [clip-name params]
+                                         (call-js engine "updateClipParams" clip-name params))
+                     :setSnippetTime (fn [clip-name offset-sec]
+                                       (or (call-js engine "setSnippetTime" clip-name offset-sec)
+                                           (call-js engine "seekSnippet" clip-name offset-sec)
+                                           (call-js engine "seek" clip-name offset-sec)))
+                     :cleanupSnippet (fn [clip-name]
+                                       (or (call-js engine "cleanupSnippet" clip-name)
+                                           (call-js engine "stopAnimation" clip-name)))
+                     :getAnimationState (fn [clip-name]
+                                          (call-js engine "getAnimationState" clip-name))}]
+    (when (js-method engine "buildTypedClip")
+      (aset runtime "buildTypedClip"
+            (fn [clip-name channels options]
+              (call-js engine "buildTypedClip" clip-name channels options))))
+    (when (or (js-method engine "playTypedSnippet")
+              (js-method engine "buildTypedClip"))
+      (aset runtime "playTypedSnippet"
+            (fn [snippet options]
+              (let [clip-name (aget snippet "name")
+                    channels (aget snippet "channels")]
+                (or
+                 (call-js engine "playTypedSnippet" snippet options)
+                 (play-built-handle!
+                  (call-js engine "buildTypedClip" clip-name channels options)))))))
+    runtime))
+
+(defn config->runtime [config]
+  (let [config (or config #js {})
+        runtime (aget config "runtime")
+        engine (aget config "engine")]
+    (cond
+      runtime runtime
+      engine (engine->runtime engine)
+      :else nil)))
+
+(defn typed-snippet-js [name channels]
+  (clj->js {:name name :channels channels}))
+
+(defn play-typed-snippet! [runtime snippet options]
+  (let [name (:name snippet)
+        channels (domain/typed-channels snippet)
+        channels-js (clj->js channels)
+        clip-options (domain/snippet->clip-options snippet options)
+        snippet-js (typed-snippet-js name channels)]
+    (if (false? (:autoPlay options))
+      (or (call-js runtime "buildTypedClip" name channels-js clip-options)
+          (call-js runtime "playTypedSnippet" snippet-js clip-options))
+      (or (call-js runtime "playTypedSnippet" snippet-js clip-options)
+          (play-built-handle!
+           (call-js runtime "buildTypedClip" name channels-js clip-options))))))
+
+(defn play-legacy-snippet! [runtime snippet options]
+  (when-let [curves (:curves snippet)]
+    (let [name (:name snippet)
+          curves-js (clj->js curves)
+          clip-options (domain/snippet->legacy-clip-options snippet options)]
+      (if (false? (:autoPlay options))
+        (or (call-js runtime "buildClip" name curves-js clip-options)
+            (call-js runtime "playSnippet" name curves-js clip-options))
+        (call-js runtime "playSnippet" name curves-js clip-options)))))
+
+(defn play-snippet! [runtime snippet options]
+  ;; Typed snippets are Polymer's canonical animation contract. Legacy curve
+  ;; playback is only a compatibility path for runtimes that have not adopted
+  ;; typed channels yet.
+  (if (domain/typed-channels snippet)
+    (if (or (js-method runtime "playTypedSnippet")
+            (js-method runtime "buildTypedClip"))
+      (play-typed-snippet! runtime snippet options)
+      (when (seq (:curves snippet))
+        (play-legacy-snippet! runtime snippet options)))
+    (play-legacy-snippet! runtime snippet options)))
+
+(defn cleanup-snippet! [runtime handle name]
+  (when-let [stop (js-method handle "stop")]
+    (.call stop handle))
+  (when runtime
+    (call-js runtime "cleanupSnippet" name)))
+
+(defn seek-snippet! [runtime handle name offset-sec]
+  (let [normalized-offset (max 0 (or offset-sec 0))]
+    (or (when handle
+          (or (call-js handle "setTime" normalized-offset)
+              (call-js handle "seek" normalized-offset)))
+        (when runtime
+          (or (call-js runtime "setSnippetTime" name normalized-offset)
+              (call-js runtime "seekSnippet" name normalized-offset)
+              (call-js runtime "seek" name normalized-offset)
+              (call-js runtime "updateClipParams"
+                       name
+                       (clj->js {:time normalized-offset
+                                 :offsetSec normalized-offset})))))))
+
+(defn update-snippet! [runtime handle name params]
+  (let [params-js (clj->js params)]
+    (or (when handle
+          (or (call-js handle "updateParams" params-js)
+              (call-js handle "setParams" params-js)))
+        (when runtime
+          (call-js runtime "updateClipParams" name params-js)))))

package/src/polymer/animation/scheduler.cljs

@@ -0,0 +1,178 @@
+(ns polymer.animation.scheduler
+  (:require [polymer.animation.domain :as domain]
+            [polymer.animation.runtime :as runtime]
+            [polymer.animation.state :as state]))
+
+;; The scheduler owns Animation's ordered work queue and runtime handle
+;; lifecycle. Other agencies request animation as plain data; only this
+;; scheduler decides when to schedule, replace, cancel, seek, or update a
+;; runtime clip.
+
+(def default-cleanup-buffer-ms 50)
+
+(defn create-scheduler [{:keys [runtime state-atom emit-event disposed? debug-log! cleanup-buffer-ms]
+                         :or {cleanup-buffer-ms default-cleanup-buffer-ms
+                              debug-log! (fn [_label _payload] nil)}}]
+  (let [cleanup-timers (atom {})
+        handles (atom {})
+        generation (atom 0)
+        queue (atom [])
+        draining? (atom false)]
+    (letfn [(next-token! []
+              (swap! generation inc))
+
+            (handle-for [name]
+              (:handle (get @handles name)))
+
+            (current-token? [name token]
+              (= token (:token (get @handles name))))
+
+            (clear-cleanup! [name]
+              (when-let [entry (get @cleanup-timers name)]
+                (js/clearTimeout (:timer entry))
+                (swap! cleanup-timers dissoc name)))
+
+            (clear-all-cleanups! []
+              (doseq [[_ entry] @cleanup-timers]
+                (js/clearTimeout (:timer entry)))
+              (reset! cleanup-timers {}))
+
+            (emit-error! [message]
+              (emit-event {:type "error"
+                           :agency "animation"
+                           :message message}))
+
+            (cleanup-runtime! [name]
+              (let [handle (handle-for name)]
+                (runtime/cleanup-snippet! runtime handle name))
+              (swap! handles dissoc name))
+
+            (emit-remove! [name source-agency reason]
+              (when (and (not @disposed?)
+                         (get-in @state-atom [:scheduled name]))
+                (clear-cleanup! name)
+                (cleanup-runtime! name)
+                (let [removed-at (state/now-ms)]
+                  (swap! state-atom state/record-remove name source-agency removed-at reason)
+                  (emit-event {:type "animationSnippetRemoved"
+                               :agency "animation"
+                               :sourceAgency source-agency
+                               :reason reason
+                               :name name
+                               :removedAt removed-at}))))
+
+            (emit-remove-if-current! [name source-agency reason token]
+              ;; Runtime handles may resolve after a replacement. The token
+              ;; prevents an old completion callback from removing the newer
+              ;; snippet that reused the same name.
+              (when (current-token? name token)
+                (emit-remove! name source-agency reason)))
+
+            (schedule-cleanup! [name snippet source-agency handle token]
+              (clear-cleanup! name)
+              (when-let [finished (aget handle "finished")]
+                (when (runtime/js-callable? (aget finished "then"))
+                  (.then finished
+                         #(emit-remove-if-current! name source-agency "completed" token)
+                         (fn [_error] nil))))
+              (when (not (:loop snippet))
+                (when-let [duration-ms (state/snippet-duration-ms snippet)]
+                  (when (pos? duration-ms)
+                    (let [timer (js/setTimeout
+                                 #(emit-remove-if-current! name source-agency "completed" token)
+                                 (+ duration-ms cleanup-buffer-ms))]
+                      (swap! cleanup-timers assoc name {:timer timer
+                                                        :token token}))))))
+
+            (schedule-snippet! [{:keys [sourceAgency requestedAt snippet options]}]
+              (let [name (:name snippet)
+                    token (next-token!)]
+                (when (get-in @state-atom [:scheduled name])
+                  (emit-remove! name sourceAgency "replaced"))
+                (debug-log! "[Polymer Animation CLJS] scheduleSnippet"
+                            (domain/schedule-log-payload snippet options sourceAgency))
+                (swap! state-atom state/record-schedule snippet options sourceAgency requestedAt)
+                (emit-event {:type "animationSnippetScheduled"
+                             :agency "animation"
+                             :sourceAgency sourceAgency
+                             :name name
+                             :snippet snippet
+                             :options options
+                             :requestedAt requestedAt})
+                (if runtime
+                  (if-let [handle (runtime/play-snippet! runtime snippet options)]
+                    (do
+                      (swap! handles assoc name {:handle handle
+                                                 :token token})
+                      (swap! state-atom state/record-start name sourceAgency (state/now-ms))
+                      (emit-event {:type "animationSnippetStarted"
+                                   :agency "animation"
+                                   :sourceAgency sourceAgency
+                                   :name name})
+                      (schedule-cleanup! name snippet sourceAgency handle token))
+                    (emit-error! (str "Animation runtime did not return a clip handle for " name)))
+                  (emit-error! "Animation agency requires an animation runtime or engine"))
+                snippet))
+
+            (seek-snippet! [{:keys [sourceAgency name offsetSec]}]
+              (if (runtime/seek-snippet! runtime (handle-for name) name offsetSec)
+                (let [seeked-at (state/now-ms)]
+                  (swap! state-atom state/record-seek name sourceAgency seeked-at offsetSec)
+                  (emit-event {:type "animationSnippetSeeked"
+                               :agency "animation"
+                               :sourceAgency sourceAgency
+                               :name name
+                               :offsetSec offsetSec
+                               :seekedAt seeked-at}))
+                (emit-error! (str "Animation runtime could not seek " name))))
+
+            (update-snippet! [{:keys [sourceAgency name params]}]
+              (if (runtime/update-snippet! runtime (handle-for name) name params)
+                (let [updated-at (state/now-ms)]
+                  (swap! state-atom state/record-update name sourceAgency updated-at params)
+                  (emit-event {:type "animationSnippetUpdated"
+                               :agency "animation"
+                               :sourceAgency sourceAgency
+                               :name name
+                               :params params
+                               :updatedAt updated-at}))
+                (emit-error! (str "Animation runtime could not update " name))))
+
+            (clear! [{:keys [sourceAgency names]}]
+              (doseq [name names]
+                (emit-remove! name sourceAgency "clear"))
+              (clear-all-cleanups!))
+
+            (run-action! [action]
+              (case (:op action)
+                :schedule (schedule-snippet! action)
+                :remove (emit-remove! (:name action) (:sourceAgency action) (:reason action))
+                :seek (seek-snippet! action)
+                :update (update-snippet! action)
+                :clear (clear! action)
+                :error (emit-error! (:message action))
+                (emit-error! (str "Unknown Animation scheduler action: " (:op action)))))
+
+            (drain! []
+              (when-not @draining?
+                (reset! draining? true)
+                (try
+                  (loop []
+                    (when-let [action (first @queue)]
+                      (swap! queue #(vec (rest %)))
+                      (run-action! action)
+                      (recur)))
+                  (finally
+                    (reset! draining? false)))))
+
+            (enqueue-actions! [actions]
+              (swap! queue into actions)
+              (drain!))
+
+            (dispose! []
+              (doseq [name (keys @handles)]
+                (cleanup-runtime! name))
+              (clear-all-cleanups!)
+              (reset! queue []))]
+      {:enqueue-actions! enqueue-actions!
+       :dispose! dispose!})))