flet-web 0.25.0__py3-none-any.whl

flet_web/web/assets/packages/record_web/assets/js/record.worklet.js

@@ -0,0 +1,400 @@
+class RecorderProcessor extends AudioWorkletProcessor {
+  static get parameterDescriptors() {
+    return [
+      {
+        name: 'numChannels',
+        defaultValue: 1,
+        minValue: 1,
+        maxValue: 16
+      },
+      {
+        name: 'sampleRate',
+        defaultValue: 48000,
+        minValue: 8000,
+        maxValue: 96000
+      }
+    ];
+  }
+
+  // Buffer size compromise between size and process call frequency
+  _bufferSize = 4096
+  // The current buffer fill level
+  _bytesWritten = 0
+  // Buffer per channel
+  _buffers = []
+  // Resampler (passthrough, down or up)
+  _resampler = null
+  // Config
+  _numChannels = 1
+  _sampleRate = 48000
+
+  constructor(options) {
+    super(options)
+
+    this._numChannels = options.parameterData.numChannels
+    this._sampleRate = options.parameterData.sampleRate
+
+    // Resampler(current context sample rate, desired sample rate, num channels, buffer size)
+    // num channels is always 1 since we resample after interleaving channels
+    this._resampler = new Resampler(sampleRate, this._sampleRate, 1, this._bufferSize * this._numChannels)
+
+    this.initBuffers()
+  }
+
+  initBuffers() {
+    this._bytesWritten = 0
+    this._buffers = []
+
+    for (let channel = 0; channel < this._numChannels; channel++) {
+      this._buffers[channel] = []
+    }
+  }
+
+  /**
+   * @returns {boolean}
+   */
+  isBufferEmpty() {
+    return this._bytesWritten === 0
+  }
+
+  /**
+   * @returns {boolean}
+   */
+  isBufferFull() {
+    return this._bytesWritten >= this._bufferSize
+  }
+
+  /**
+   * @param {Float32Array[][]} inputs
+   * @returns {boolean}
+   */
+  process(inputs) {
+    if (this.isBufferFull()) {
+      this.flush()
+    }
+
+    const input = inputs[0]
+
+    if (input.length == 0) {
+      // Sometimes, Firefox doesn't give any input. Skip this frame to not fail.
+      return true
+    }
+
+    for (let channel = 0; channel < this._numChannels; channel++) {
+      // Push a copy of the array.
+      // The underlying implementation may reuse it which will break the recording.
+      this._buffers[channel].push([...input[channel]])
+    }
+
+    this._bytesWritten += input[0].length
+
+    return true
+  }
+
+  flush() {
+    let channels = []
+    for (let channel = 0; channel < this._numChannels; channel++) {
+      channels.push(this.mergeFloat32Arrays(this._buffers[channel], this._bytesWritten))
+    }
+
+    let interleaved = this.interleave(channels)
+
+    let resampled = this._resampler.resample(interleaved)
+
+    this.port.postMessage(this.floatTo16BitPCM(resampled))
+
+    this.initBuffers()
+  }
+
+  mergeFloat32Arrays(arrays, bytesWritten) {
+    let result = new Float32Array(bytesWritten)
+    var offset = 0
+
+    for (let i = 0; i < arrays.length; i++) {
+      result.set(arrays[i], offset)
+      offset += arrays[i].length
+    }
+
+    return result
+  }
+
+  // Interleave data from channels from LLLLRRRR to LRLRLRLR
+  interleave(channels) {
+    if (channels === 1) {
+      return channels[0]
+    }
+
+    var length = 0
+    for (let i = 0; i < channels.length; i++) {
+      length += channels[i].length
+    }
+
+    let result = new Float32Array(length)
+
+    var index = 0
+    var inputIndex = 0
+
+    while (index < length) {
+      for (let i = 0; i < channels.length; i++) {
+        result[index] = channels[i][inputIndex]
+        index++
+      }
+
+      inputIndex++
+    }
+
+    return result
+  }
+
+  floatTo16BitPCM(input) {
+    let output = new DataView(new ArrayBuffer(input.length * 2))
+
+    for (let i = 0; i < input.length; i++) {
+      let s = Math.max(-1, Math.min(1, input[i]))
+      let s16 = s < 0 ? s * 0x8000 : s * 0x7FFF
+      output.setInt16(i * 2, s16, true)
+    }
+
+    return new Int16Array(output.buffer)
+  }
+}
+
+class Resampler {
+  constructor(fromSampleRate, toSampleRate, channels, inputBufferSize) {
+
+    if (!fromSampleRate || !toSampleRate || !channels) {
+      throw (new Error("Invalid settings specified for the resampler."));
+    }
+    this.resampler = null;
+    this.fromSampleRate = fromSampleRate;
+    this.toSampleRate = toSampleRate;
+    this.channels = channels || 0;
+    this.inputBufferSize = inputBufferSize;
+    this.initialize()
+  }
+
+  initialize() {
+    if (this.fromSampleRate == this.toSampleRate) {
+
+      // Setup resampler bypass - Resampler just returns what was passed through
+      this.resampler = (buffer) => {
+        return buffer
+      };
+      this.ratioWeight = 1;
+
+    } else {
+      if (this.fromSampleRate < this.toSampleRate) {
+
+        // Use generic linear interpolation if upsampling,
+        // as linear interpolation produces a gradient that we want
+        // and works fine with two input sample points per output in this case.
+        this.linearInterpolation();
+        this.lastWeight = 1;
+
+      } else {
+
+        // Custom resampler I wrote that doesn't skip samples
+        // like standard linear interpolation in high downsampling.
+        // This is more accurate than linear interpolation on downsampling.
+        this.multiTap();
+        this.tailExists = false;
+        this.lastWeight = 0;
+      }
+
+      // Initialize the internal buffer:
+      this.initializeBuffers();
+      this.ratioWeight = this.fromSampleRate / this.toSampleRate;
+    }
+  }
+
+  bufferSlice(sliceAmount) {
+
+    //Typed array and normal array buffer section referencing:
+    try {
+      return this.outputBuffer.subarray(0, sliceAmount);
+    }
+    catch (error) {
+      try {
+        //Regular array pass:
+        this.outputBuffer.length = sliceAmount;
+        return this.outputBuffer;
+      }
+      catch (error) {
+        //Nightly Firefox 4 used to have the subarray function named as slice:
+        return this.outputBuffer.slice(0, sliceAmount);
+      }
+    }
+  }
+
+  initializeBuffers() {
+    this.outputBufferSize = (Math.ceil(this.inputBufferSize * this.toSampleRate / this.fromSampleRate / this.channels * 1.000000476837158203125) + this.channels) + this.channels;
+    try {
+      this.outputBuffer = new Float32Array(this.outputBufferSize);
+      this.lastOutput = new Float32Array(this.channels);
+    }
+    catch (error) {
+      this.outputBuffer = [];
+      this.lastOutput = [];
+    }
+  }
+
+  linearInterpolation() {
+    this.resampler = (buffer) => {
+      let bufferLength = buffer.length,
+        channels = this.channels,
+        outLength,
+        ratioWeight,
+        weight,
+        firstWeight,
+        secondWeight,
+        sourceOffset,
+        outputOffset,
+        outputBuffer,
+        channel;
+
+      if ((bufferLength % channels) !== 0) {
+        throw (new Error("Buffer was of incorrect sample length."));
+      }
+      if (bufferLength <= 0) {
+        return [];
+      }
+
+      outLength = this.outputBufferSize;
+      ratioWeight = this.ratioWeight;
+      weight = this.lastWeight;
+      firstWeight = 0;
+      secondWeight = 0;
+      sourceOffset = 0;
+      outputOffset = 0;
+      outputBuffer = this.outputBuffer;
+
+      for (; weight < 1; weight += ratioWeight) {
+        secondWeight = weight % 1;
+        firstWeight = 1 - secondWeight;
+        this.lastWeight = weight % 1;
+        for (channel = 0; channel < this.channels; ++channel) {
+          outputBuffer[outputOffset++] = (this.lastOutput[channel] * firstWeight) + (buffer[channel] * secondWeight);
+        }
+      }
+      weight -= 1;
+      for (bufferLength -= channels, sourceOffset = Math.floor(weight) * channels; outputOffset < outLength && sourceOffset < bufferLength;) {
+        secondWeight = weight % 1;
+        firstWeight = 1 - secondWeight;
+        for (channel = 0; channel < this.channels; ++channel) {
+          outputBuffer[outputOffset++] = (buffer[sourceOffset + ((channel > 0) ? (channel) : 0)] * firstWeight) + (buffer[sourceOffset + (channels + channel)] * secondWeight);
+        }
+        weight += ratioWeight;
+        sourceOffset = Math.floor(weight) * channels;
+      }
+      for (channel = 0; channel < channels; ++channel) {
+        this.lastOutput[channel] = buffer[sourceOffset++];
+      }
+      return this.bufferSlice(outputOffset);
+    };
+  }
+
+  multiTap() {
+    this.resampler = (buffer) => {
+      let bufferLength = buffer.length,
+        outLength,
+        output_variable_list,
+        channels = this.channels,
+        ratioWeight,
+        weight,
+        channel,
+        actualPosition,
+        amountToNext,
+        alreadyProcessedTail,
+        outputBuffer,
+        outputOffset,
+        currentPosition;
+
+      if ((bufferLength % channels) !== 0) {
+        throw (new Error("Buffer was of incorrect sample length."));
+      }
+      if (bufferLength <= 0) {
+        return [];
+      }
+
+      outLength = this.outputBufferSize;
+      output_variable_list = [];
+      ratioWeight = this.ratioWeight;
+      weight = 0;
+      actualPosition = 0;
+      amountToNext = 0;
+      alreadyProcessedTail = !this.tailExists;
+      this.tailExists = false;
+      outputBuffer = this.outputBuffer;
+      outputOffset = 0;
+      currentPosition = 0;
+
+      for (channel = 0; channel < channels; ++channel) {
+        output_variable_list[channel] = 0;
+      }
+
+      do {
+        if (alreadyProcessedTail) {
+          weight = ratioWeight;
+          for (channel = 0; channel < channels; ++channel) {
+            output_variable_list[channel] = 0;
+          }
+        } else {
+          weight = this.lastWeight;
+          for (channel = 0; channel < channels; ++channel) {
+            output_variable_list[channel] = this.lastOutput[channel];
+          }
+          alreadyProcessedTail = true;
+        }
+        while (weight > 0 && actualPosition < bufferLength) {
+          amountToNext = 1 + actualPosition - currentPosition;
+          if (weight >= amountToNext) {
+            for (channel = 0; channel < channels; ++channel) {
+              output_variable_list[channel] += buffer[actualPosition++] * amountToNext;
+            }
+            currentPosition = actualPosition;
+            weight -= amountToNext;
+          } else {
+            for (channel = 0; channel < channels; ++channel) {
+              output_variable_list[channel] += buffer[actualPosition + ((channel > 0) ? channel : 0)] * weight;
+            }
+            currentPosition += weight;
+            weight = 0;
+            break;
+          }
+        }
+
+        if (weight === 0) {
+          for (channel = 0; channel < channels; ++channel) {
+            outputBuffer[outputOffset++] = output_variable_list[channel] / ratioWeight;
+          }
+        } else {
+          this.lastWeight = weight;
+          for (channel = 0; channel < channels; ++channel) {
+            this.lastOutput[channel] = output_variable_list[channel];
+          }
+          this.tailExists = true;
+          break;
+        }
+      } while (actualPosition < bufferLength && outputOffset < outLength);
+      return this.bufferSlice(outputOffset);
+    };
+  }
+
+  resample(buffer) {
+    if (this.fromSampleRate == this.toSampleRate) {
+      this.ratioWeight = 1;
+    } else {
+      if (this.fromSampleRate < this.toSampleRate) {
+        this.lastWeight = 1;
+      } else {
+        this.tailExists = false;
+        this.lastWeight = 0;
+      }
+      this.initializeBuffers();
+      this.ratioWeight = this.fromSampleRate / this.toSampleRate;
+    }
+    return this.resampler(buffer)
+  }
+}
+
+registerProcessor("recorder.worklet", RecorderProcessor)

flet_web/web/assets/packages/wakelock_plus/assets/no_sleep.js

@@ -0,0 +1,230 @@
+var webm =
+  'data:video/webm;base64,GkXfo0AgQoaBAUL3gQFC8oEEQvOBCEKCQAR3ZWJtQoeBAkKFgQIYU4BnQI0VSalmQCgq17FAAw9CQE2AQAZ3aGFtbXlXQUAGd2hhbW15RIlACECPQAAAAAAAFlSua0AxrkAu14EBY8WBAZyBACK1nEADdW5khkAFVl9WUDglhohAA1ZQOIOBAeBABrCBCLqBCB9DtnVAIueBAKNAHIEAAIAwAQCdASoIAAgAAUAmJaQAA3AA/vz0AAA='
+var mp4 =
+  'data:video/mp4;base64,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'
+
+var _createClass = (function () {
+  function defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i]
+      descriptor.enumerable = descriptor.enumerable || false
+      descriptor.configurable = true
+      if ('value' in descriptor) descriptor.writable = true
+      Object.defineProperty(target, descriptor.key, descriptor)
+    }
+  }
+  return function (Constructor, protoProps, staticProps) {
+    if (protoProps) defineProperties(Constructor.prototype, protoProps)
+    if (staticProps) defineProperties(Constructor, staticProps)
+    return Constructor
+  }
+})()
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError('Cannot call a class as a function')
+  }
+}
+
+// Detect iOS browsers < version 10
+var oldIOS =
+  typeof navigator !== 'undefined' &&
+  parseFloat(
+    (
+      '' +
+      (/CPU.*OS ([0-9_]{3,4})[0-9_]{0,1}|(CPU like).*AppleWebKit.*Mobile/i.exec(
+        navigator.userAgent
+      ) || [0, ''])[1]
+    )
+      .replace('undefined', '3_2')
+      .replace('_', '.')
+      .replace('_', '')
+  ) < 10 &&
+  !window.MSStream
+
+// Detect native Wake Lock API support
+var nativeWakeLock = 'wakeLock' in navigator
+
+var NoSleep = (function () {
+  var _releasedNative = true
+  var _nativeRequestInProgress = false
+
+  function NoSleep() {
+    var _this = this
+
+    _classCallCheck(this, NoSleep)
+
+    if (nativeWakeLock) {
+      this._wakeLock = null
+      var handleVisibilityChange = function handleVisibilityChange() {
+        if (
+          _this._wakeLock !== null &&
+          document.visibilityState === 'visible'
+        ) {
+          _this.enable()
+        }
+      }
+      document.addEventListener('visibilitychange', handleVisibilityChange)
+      document.addEventListener('fullscreenchange', handleVisibilityChange)
+    } else if (oldIOS) {
+      this.noSleepTimer = null
+    } else {
+      // Set up no sleep video element
+      this.noSleepVideo = document.createElement('video')
+
+      this.noSleepVideo.setAttribute('title', 'No Sleep')
+      this.noSleepVideo.setAttribute('playsinline', '')
+
+      this._addSourceToVideo(this.noSleepVideo, 'webm', webm)
+      this._addSourceToVideo(this.noSleepVideo, 'mp4', mp4)
+
+      this.noSleepVideo.addEventListener('loadedmetadata', function () {
+        if (_this.noSleepVideo.duration <= 1) {
+          // webm source
+          _this.noSleepVideo.setAttribute('loop', '')
+        } else {
+          // mp4 source
+          _this.noSleepVideo.addEventListener('timeupdate', function () {
+            if (_this.noSleepVideo.currentTime > 0.5) {
+              _this.noSleepVideo.currentTime = Math.random()
+            }
+          })
+        }
+      })
+    }
+  }
+
+  _createClass(NoSleep, [
+    {
+      key: '_addSourceToVideo',
+      value: function _addSourceToVideo(element, type, dataURI) {
+        var source = document.createElement('source')
+        source.src = dataURI
+        source.type = 'video/' + type
+        element.appendChild(source)
+      },
+    },
+    {
+      key: 'enable',
+      value: function enable() {
+        var _this2 = this
+
+        if (nativeWakeLock) {
+          _nativeRequestInProgress = true
+          navigator.wakeLock
+            .request('screen')
+            .then(function (wakeLock) {
+              _releasedNative = false
+              _nativeRequestInProgress = false
+
+              _this2._wakeLock = wakeLock
+              _this2._wakeLock.addEventListener('release', function () {
+                _releasedNative = true
+                _this2._wakeLock = null
+              })
+            })
+            .catch(function (err) {
+              _nativeRequestInProgress = false
+              console.error(err.name + ', ' + err.message)
+            })
+        } else if (oldIOS) {
+          this.disable()
+          console.warn(
+            '\n        NoSleep enabled for older iOS devices. This can interrupt\n        active or long-running network requests from completing successfully.\n        See https://github.com/richtr/NoSleep.js/issues/15 for more details.\n      '
+          )
+          this.noSleepTimer = window.setInterval(function () {
+            if (!document.hidden) {
+              window.location.href = window.location.href.split('#')[0]
+              window.setTimeout(window.stop, 0)
+            }
+          }, 15000)
+        } else {
+          this.noSleepVideo.play()
+        }
+      },
+    },
+    {
+      key: 'disable',
+      value: function disable() {
+        if (nativeWakeLock) {
+          if (this._wakeLock != null) {
+            _releasedNative = true
+            this._wakeLock.release()
+          }
+
+          this._wakeLock = null
+        } else if (oldIOS) {
+          if (this.noSleepTimer) {
+            console.warn(
+              '\n          NoSleep now disabled for older iOS devices.\n        '
+            )
+            window.clearInterval(this.noSleepTimer)
+            this.noSleepTimer = null
+          }
+        } else {
+          this.noSleepVideo.pause()
+        }
+      },
+    },
+    {
+      key: 'enabled',
+      value: async function enabled() {
+        if (nativeWakeLock) {
+          if (_nativeRequestInProgress == true) {
+            // Wait until the request is done.
+            while (true) {
+              // Wait for 42 milliseconds.
+              await new Promise((resolve, reject) => setTimeout(resolve, 42))
+              if (_nativeRequestInProgress == false) {
+                break
+              }
+            }
+          }
+
+          // todo: use WakeLockSentinel.released when that is available (https://developer.mozilla.org/en-US/docs/Web/API/WakeLockSentinel/released)
+          if (_releasedNative != false) {
+            return false
+          }
+
+          return true
+        } else if (oldIOS) {
+          return this.noSleepTimer != null
+        } else {
+          if (this.noSleepVideo == undefined) {
+            return false
+          }
+
+          return !this.noSleepVideo.paused
+        }
+      },
+    },
+  ])
+
+  return NoSleep
+})()
+
+var noSleep = new NoSleep()
+
+var Wakelock = {
+  enabled: async function () {
+    try {
+      return noSleep.enabled()
+    } catch (e) {
+      return false
+    }
+  },
+  toggle: async function (enable) {
+    if (enable) {
+      noSleep.enable()
+    } else {
+      noSleep.disable()
+    }
+  },
+}
+
+if (nativeWakeLock != true) {
+  // The first non-native call sometimes throws an error, however,
+  // the error does not leak the try-catch above. Therefore, this
+  // is an easy fix that realiably works.
+  Wakelock.enabled()
+}