Skip to content

GitLab

Commit 9c04dc7b authored by DFN2's avatar DFN2
Browse files

initial commit

parent b0d72a8d
Pipeline #936 passed with stage
in 7 minutes and 18 seconds
Expand all Hide whitespace changes
Inline Side-by-side
.gitignore 0 → 100644
View file @ 9c04dc7b
build_*/
node_modules/
dist/
ocs-manager
.gitlab-ci.yml 0 → 100644
View file @ 9c04dc7b
stages:
- build
appimage:
stage: build
image: ubuntu:14.04
script:
- ./scripts/package appimage
artifacts:
paths:
- build_*/pling-store*.AppImage*
expire_in: 2 days
Makefile 0 → 100644
View file @ 9c04dc7b
SHELL = /bin/sh
TARGET = pling-store
srcdir = .
DESTDIR =
prefix = /usr/local
exec_prefix = $(prefix)
bindir = $(exec_prefix)/bin
libdir = $(exec_prefix)/lib
datadir = $(prefix)/share
INSTALL = install
INSTALL_PROGRAM = $(INSTALL) -D -m 755
INSTALL_DATA = $(INSTALL) -D -m 644
MKDIR = mkdir -p
CP = cp -Rpf
RM = rm -rf
.PHONY: all rebuild build clean install uninstall
all: rebuild ;
rebuild: clean build ;
build: $(TARGET) ;
clean:
$(RM) $(srcdir)/node_modules
$(RM) $(srcdir)/dist
install:
$(INSTALL_PROGRAM) $(srcdir)/launcher/$(TARGET) $(DESTDIR)$(bindir)/$(TARGET)
$(MKDIR) $(DESTDIR)$(libdir)
$(CP) $(srcdir)/dist/$(TARGET)-linux-x64 $(DESTDIR)$(libdir)
$(INSTALL_DATA) $(srcdir)/desktop/$(TARGET).desktop $(DESTDIR)$(datadir)/applications/$(TARGET).desktop
$(INSTALL_DATA) $(srcdir)/desktop/$(TARGET).svg $(DESTDIR)$(datadir)/icons/hicolor/scalable/apps/$(TARGET).svg
uninstall:
$(RM) $(DESTDIR)$(bindir)/$(TARGET)
$(RM) $(DESTDIR)$(libdir)/$(TARGET)-linux-x64
$(RM) $(DESTDIR)$(datadir)/applications/$(TARGET).desktop
$(RM) $(DESTDIR)$(datadir)/icons/hicolor/scalable/apps/$(TARGET).svg
$(TARGET): $(TARGET)-linux-x64 ;
$(TARGET)-linux-x64:
cd $(srcdir) ; \
npm install ; \
npm run package
app/configs/application.json 0 → 100644
View file @ 9c04dc7b
{
"defaults": {
"startPage": "https://www.pling.com/",
"windowBounds": {
"x": 0,
"y": 0,
"width": 1024,
"height": 768
}
},
"updateCheckAfter": 86400000, "//": "milliseconds"
}
app/configs/ocs-manager.json 0 → 100644
View file @ 9c04dc7b
{
"bin": "ocs-manager",
"port": 0
}
app/images/app-icons/ocs-store.svg 0 → 100644
View file @ 9c04dc7b
This diff is collapsed.
app/images/app-icons/pling-store.svg 0 → 100755
View file @ 9c04dc7b
This diff is collapsed.
app/images/icon.css 0 → 100644
View file @ 9c04dc7b
.icon-ocs-store {
background-image: url(app-icons/pling-store.svg);
}
app/index.html 0 → 100644
View file @ 9c04dc7b
<!DOCTYPE html>
<html lang="en">
<head>
<meta http-equiv="Content-Security-Policy"
content="default-src 'self' 'unsafe-inline'; connect-src *">
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<meta name="format-detection" content="telephone=no, email=no, address=no">
<title></title>
<link href="styles/reset.css" rel="stylesheet">
<link href="styles/color.css" rel="stylesheet">
<link href="styles/material-icons.css" rel="stylesheet">
<link href="styles/global.css" rel="stylesheet">
</head>
<body>
<app-root></app-root>
<script>
require = require('esm')(module);
module.exports = require('./scripts/renderers/browser-window.js');
</script>
</body>
</html>
app/libs/chirit/Chirit.js 0 → 100644
View file @ 9c04dc7b
/**
* Chirit
*
* @author Akira Ohgaki <akiraohgaki@gmail.com>
* @copyright 2018, Akira Ohgaki
* @license https://opensource.org/licenses/BSD-2-Clause
* @link https://github.com/akiraohgaki/chirit
*/
import Component from './Component.js';
import StateManager from './StateManager.js';
import Handler from './Handler.js';
import WebStorage from './WebStorage.js';
import Utility from './Utility.js';
export default class Chirit {
static get Component() {
return Component;
}
static get StateManager() {
return StateManager;
}
static get Handler() {
return Handler;
}
static get WebStorage() {
return WebStorage;
}
static get Utility() {
return Utility;
}
}
app/libs/chirit/Component.js 0 → 100644
View file @ 9c04dc7b
/**
* Chirit
*
* @author Akira Ohgaki <akiraohgaki@gmail.com>
* @copyright 2018, Akira Ohgaki
* @license https://opensource.org/licenses/BSD-2-Clause
* @link https://github.com/akiraohgaki/chirit
*/
export default class Component extends HTMLElement {
static define(name, options) {
window.customElements.define(name, this, options);
}
constructor() {
super();
this._state = {};
this._shadowRoot = null;
this._template = null;
this._updateCount = 0;
this.initShadow();
this.initTemplate();
this.init();
}
set state(state) {
this.setState(state);
}
get state() {
return this.getState();
}
get contentRoot() {
return this._shadowRoot || this.shadowRoot || this;
}
initShadow() {
this.enableShadow();
}
initTemplate() {
this.importTemplate(document.createElement('template'));
}
setState(state) {
if (typeof state !== 'object' || state === null) {
throw new TypeError(`"${state}" is not an object`);
}
const oldState = Object.assign({}, this._state);
this._state = state;
const newState = Object.assign({}, this._state);
this._stateChangedCallback(oldState, newState);
}
getState() {
return this._state;
}
setContent(content) {
// "content" should be Node object or string
if (typeof content === 'string') {
const template = document.createElement('template');
template.innerHTML = content;
content = template.content;
}
const oldContent = this.exportTemplate().content;
this._template.content.textContent = null;
this._template.content.appendChild(content);
const newContent = this.exportTemplate().content;
this.contentRoot.textContent = null;
this.contentRoot.appendChild(newContent.cloneNode(true));
this._contentChangedCallback(oldContent, newContent);
}
enableShadow(options = {}) {
this._shadowRoot = this.attachShadow(Object.assign(
{mode: 'open'},
options
));
}
importTemplate(template) {
if (!(template instanceof HTMLTemplateElement)) {
throw new TypeError(`"${template}" is not a HTMLTemplateElement`);
}
this._template = template.cloneNode(true);
}
exportTemplate() {
return this._template.cloneNode(true);
}
dispatch(type, data = {}) {
this.dispatchEvent(new CustomEvent(type, {
detail: data,
bubbles: true,
composed: true
}));
}
update(state) {
if (state !== undefined) {
this.setState(state);
}
else {
this._update();
}
}
_update() {
let content = this.render();
if (typeof content !== 'string' && !content) {
content = this.exportTemplate().content;
}
this.setContent(content);
this._updatedCallback();
}
// Abstract methods
init() {}
render() {}
// Lifecycle methods
static get componentObservedAttributes() {
return [];
}
componentAttributeChangedCallback() {}
componentConnectedCallback() {}
componentDisconnectedCallback() {}
componentAdoptedCallback() {}
componentStateChangedCallback() {}
componentContentChangedCallback() {}
componentUpdatedCallback() {}
// Lifecycle methods in parent class
static get observedAttributes() {
return this.componentObservedAttributes;
}
attributeChangedCallback(attributeName, oldValue, newValue, namespace) {
this.componentAttributeChangedCallback(attributeName, oldValue, newValue, namespace);
if (this._updateCount && oldValue !== newValue) {
this._update();
}
}
connectedCallback() {
this.componentConnectedCallback();
if (!this._updateCount) {
this._update();
}
}
disconnectedCallback() {
this.componentDisconnectedCallback();
}
adoptedCallback(oldDocument, newDocument) {
this.componentAdoptedCallback(oldDocument, newDocument);
if (!this._updateCount) {
this._update();
}
}
// Additional lifecycle methods
_stateChangedCallback(oldState, newState) {
this.componentStateChangedCallback(oldState, newState);
//if (this._updateCount && JSON.stringify(oldState) !== JSON.stringify(newState)) {
// this.update();
//}
if (this._updateCount) {
this._update();
}
}
_contentChangedCallback(oldContent, newContent) {
this.componentContentChangedCallback(oldContent, newContent);
}
_updatedCallback() {
this._updateCount++;
this.componentUpdatedCallback();
}
}
app/libs/chirit/Handler.js 0 → 100644
View file @ 9c04dc7b
/**
* Chirit
*
* @author Akira Ohgaki <akiraohgaki@gmail.com>
* @copyright 2018, Akira Ohgaki
* @license https://opensource.org/licenses/BSD-2-Clause
* @link https://github.com/akiraohgaki/chirit
*/
export default class Handler {
constructor(handler) {
// handler:
// (data = {}, type = '') => {
// return {};
// }
this._initialHandler = handler;
this._defaultHandler = null;
this._typeHandlersCollection = new Map(); // [[type, [handler]]]
this.resetDefault();
}
resetDefault() {
this.setDefault(this._initialHandler);
return this;
}
setDefault(handler) {
this._checkTypeOfHandler(handler);
this._defaultHandler = handler;
this.defaultChangedCallback(handler);
return this;
}
add(type, handler) {
this._checkTypeOfHandler(handler);
this.beforeAddCallback(type, handler);
const typeHandlers = this._typeHandlersCollection.get(type) || new Set();
if (!typeHandlers.has(handler)) {
typeHandlers.add(handler);
this._typeHandlersCollection.set(type, typeHandlers);
this.afterAddCallback(type, handler);
}
return this;
}
remove(type, handler) {
this._checkTypeOfHandler(handler);
this.beforeRemoveCallback(type, handler);
if (this._typeHandlersCollection.has(type)) {
const typeHandlers = this._typeHandlersCollection.get(type);
if (typeHandlers.has(handler)) {
typeHandlers.delete(handler);
if (typeHandlers.size) {
this._typeHandlersCollection.set(type, typeHandlers);
}
else {
this._typeHandlersCollection.delete(type);
}
this.afterRemoveCallback(type, handler);
}
}
return this;
}
has(type) {
return this._typeHandlersCollection.has(type);
}
async invoke(data = {}, type = '') {
// This function will wrap and call registered handlers with Promise and Promise.all().
// And all return values of the same type of handlers will be combined in object finally.
// If any handler returned false, will not combine values and return null.
const promises = [];
promises.push(new Promise((resolve) => {
resolve(this._defaultHandler(data, type));
}));
if (type && this._typeHandlersCollection.has(type)) {
const typeHandlers = this._typeHandlersCollection.get(type);
for (const handler of typeHandlers) {
promises.push(new Promise((resolve) => {
resolve(handler(data, type));
}));
}
}
const values = await Promise.all(promises);
if (values.includes(false)) {
return null;
}
const combinedData = {};
for (const value of values) {
Object.assign(combinedData, value);
}
return combinedData;
}
defaultChangedCallback() {}
beforeAddCallback() {}
afterAddCallback() {}
beforeRemoveCallback() {}
afterRemoveCallback() {}
_checkTypeOfHandler(handler) {
if (typeof handler !== 'function') {
throw new TypeError(`"${handler}" is not a function`);
}
}
}
app/libs/chirit/README.md 0 → 100644
View file @ 9c04dc7b
# Chirit
[![License](https://img.shields.io/badge/License-BSD%202--Clause-orange.svg)](https://opensource.org/licenses/BSD-2-Clause)
A front-end library.
Copyright: 2018, Akira Ohgaki
License: BSD-2-Clause
app/libs/chirit/StateManager.js 0 → 100644
View file @ 9c04dc7b
/**
* Chirit
*
* @author Akira Ohgaki <akiraohgaki@gmail.com>
* @copyright 2018, Akira Ohgaki
* @license https://opensource.org/licenses/BSD-2-Clause
* @link https://github.com/akiraohgaki/chirit
*/
import Handler from './Handler.js';
export default class StateManager {
constructor(target) {
// "target" should be Element object or selector string
if (typeof target === 'string') {
target = document.querySelector(target);
}
this._target = target || document;
this._state = new Map();
this._eventListener = this._eventListener.bind(this);
this._eventHandler = null;
this._actionHandler = null;
this._stateHandler = null;
this._viewHandler = null;
this._initHandlers();
}
get target() {
return this._target;
}
get state() {
return this._state;
}
get eventHandler() {
return this._eventHandler;
}
get actionHandler() {
return this._actionHandler;
}
get stateHandler() {
return this._stateHandler;
}
get viewHandler() {
return this._viewHandler;
}
dispatch(type, data = {}) {
this._target.dispatchEvent(new CustomEvent(type, {detail: data}));
}
_eventListener(event) {
event.preventDefault();
event.stopPropagation();
this._invokeHandlers(event.detail, event.type);
}
_initHandlers() {
this._eventHandler = new Handler((data) => {
return data;
});
this._actionHandler = new Handler(() => {
return {};
});
this._stateHandler = new Handler((data, type) => {
this._state.set(type, data);
return data;
});
this._viewHandler = new Handler(() => {
return {};
});
const beforeAddCallback = (type) => {
if (!this._eventHandler.has(type)
&& !this._actionHandler.has(type)
&& !this._stateHandler.has(type)
&& !this._viewHandler.has(type)
) {
this._target.addEventListener(type, this._eventListener, false);
this._state.set(type, {});
}
};
const afterRemoveCallback = (type) => {
if (!this._eventHandler.has(type)
&& !this._actionHandler.has(type)
&& !this._stateHandler.has(type)
&& !this._viewHandler.has(type)
) {
this._target.removeEventListener(type, this._eventListener, false);
this._state.delete(type);
}