2 | 
3 |
3 |
4 |
5 |
6 | menu
7 |
8 |
9 | 
10 |
11 | {{ $appName }}
12 |
13 |
14 |
15 |
16 | Navigation
17 |
18 |
23 |
24 |
25 |
26 |
27 |
28 | list
29 | File Browser
30 |
31 |
32 |
33 |
34 |
35 | settings
36 | Settings
37 |
38 |
39 |
40 |
41 |
42 | info
43 | About
44 |
45 |
46 |
47 |
48 |
49 |
50 |
52 |
53 |
54 |
55 |
56 |
68 |
69 |
96 |
97 |
117 |
--------------------------------------------------------------------------------
/src/assets/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MkDocsEditor/MkDocsEditor-Web/c10b89f3b355d5c037bd9c89bdc06fff507d365b/src/assets/logo.png
--------------------------------------------------------------------------------
/src/business/persistence/StorageManager.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * Interface for storage implementations
3 | */
4 | export default interface StorageManager {
5 |
6 | /**
7 | * Loads a value
8 | *
9 | * @param storeKey the item key
10 | * @param defaultValue the default value to use if no persisted value was found
11 | */
12 | getValue(storeKey: string, defaultValue: any): any;
13 |
14 | /**
15 | * Saves a new value
16 | *
17 | * @param storeKey the item key
18 | * @param newValue the new value
19 | */
20 | setValue(storeKey: string, newValue: any): void;
21 |
22 | }
23 |
--------------------------------------------------------------------------------
/src/business/persistence/localstorage/LocalStorageManager.ts:
--------------------------------------------------------------------------------
1 | import StorageManager from '@/business/persistence/StorageManager';
2 |
3 | /**
4 | * Manager for general access to local storage
5 | */
6 | export default class LocalStorageManager implements StorageManager {
7 |
8 | private localStorage: any;
9 |
10 | public constructor(localStore: any) {
11 | this.localStorage = localStore;
12 | }
13 |
14 | public getValue(storeKey: string, defaultValue: any): any {
15 | let storeValue: any = localStorage.getItem(storeKey);
16 | if (storeValue) {
17 | if (storeValue instanceof Object) {
18 | // try to deserialize
19 |
20 | try {
21 | storeValue = JSON.parse(storeValue);
22 | } catch (e) {
23 | // @ts-ignore
24 | this.console.error(e);
25 | }
26 | }
27 | }
28 |
29 | if (storeValue) {
30 | return storeValue;
31 | } else {
32 | return defaultValue;
33 | }
34 | }
35 |
36 | public setValue(storeKey: string, newValue: any): void {
37 | let serialized = false;
38 | if (newValue instanceof Object) {
39 | serialized = true;
40 | }
41 |
42 | if (serialized) {
43 | // try to deserialize
44 | try {
45 | newValue = JSON.stringify(newValue);
46 | } catch (e) {
47 | // @ts-ignore
48 | this.console.error(e);
49 | }
50 | }
51 |
52 | localStorage.setItem(storeKey, newValue);
53 | }
54 | }
55 |
--------------------------------------------------------------------------------
/src/business/persistence/preferences/PreferenceItem.ts:
--------------------------------------------------------------------------------
1 | /**
2 | * Definition of a single preference item
3 | */
4 | export default class PreferenceItem {
5 |
6 | public key: string;
7 | public defaultValue: any;
8 |
9 | public constructor(key: string, defaultValue: any) {
10 | this.key = key;
11 | this.defaultValue = defaultValue;
12 | }
13 |
14 | }
15 |
--------------------------------------------------------------------------------
/src/business/persistence/preferences/PreferenceItems.ts:
--------------------------------------------------------------------------------
1 | import PreferenceItem from '@/business/persistence/preferences/PreferenceItem';
2 |
3 | /**
4 | * Preference constants
5 | */
6 | export default {
7 | Server: {
8 | URL: new PreferenceItem('SettingsServerURL', ''),
9 | Auth: {
10 | Enabled: new PreferenceItem('settingsServerAuthEnabled', false),
11 | Username: new PreferenceItem('settingsServerAuthUsername', ''),
12 | Password: new PreferenceItem('settingsServerAuthPassword', ''),
13 | },
14 |
15 | },
16 | Editor: {
17 | openDefault: new PreferenceItem('settingsEditorOpenDefault', 'both'),
18 | },
19 | };
20 |
--------------------------------------------------------------------------------
/src/business/persistence/preferences/PreferenceManger.ts:
--------------------------------------------------------------------------------
1 | import LocalStorageManager from '@/business/persistence/localstorage/LocalStorageManager';
2 | import PreferenceItem from '@/business/persistence/preferences/PreferenceItem';
3 |
4 | /**
5 | * Manager for application preferences
6 | */
7 | export default class PreferenceManager {
8 |
9 | private storageManager: LocalStorageManager;
10 |
11 | public constructor(storageManager: LocalStorageManager) {
12 | this.storageManager = storageManager;
13 | }
14 |
15 | /**
16 | * Load a preference from local storage into data section of this component
17 | *
18 | * @param preferenceItem the preference item to retrieve
19 | */
20 | public loadPreferenceValue(preferenceItem: PreferenceItem): any {
21 | const key = preferenceItem.key;
22 | const defaultValue = preferenceItem.defaultValue;
23 |
24 | return this.storageManager.getValue(key, defaultValue);
25 | }
26 |
27 | /**
28 | * Save a preference in local storage
29 | *
30 | * @param preferenceItem the preference item to set a new value for
31 | * @param newValue the new value to assign to it
32 | */
33 | public savePreferenceValue(preferenceItem: PreferenceItem, newValue: any) {
34 | const key = preferenceItem.key;
35 | if (newValue == null) {
36 | newValue = preferenceItem.defaultValue;
37 | }
38 |
39 | this.storageManager.setValue(key, newValue);
40 | }
41 |
42 | }
43 |
--------------------------------------------------------------------------------
/src/business/rest/RestClient.ts:
--------------------------------------------------------------------------------
1 | import axios, {AxiosInstance} from 'axios';
2 | import SectionModel from '@/business/rest/model/SectionModel';
3 | import DocumentModel from '@/business/rest/model/DocumentModel';
4 | import ResourceModel from '@/business/rest/model/ResourceModel';
5 | // import DocumentModel from "./model/DocumentModel.ts";
6 | // import ResourceModel from "./model/ResourceModel.ts";
7 |
8 | /**
9 | * Manager for server communication
10 | */
11 | export default class RestClient {
12 |
13 | private static toSectionModel(data: any): SectionModel {
14 | return new SectionModel(
15 | data.id,
16 | data.name,
17 | data.subsections.map(RestClient.toSectionModel),
18 | data.documents.map(RestClient.toDocumentModel),
19 | data.resources.map(RestClient.toResourceModel),
20 | );
21 | }
22 |
23 | private static toDocumentModel(data: any): DocumentModel {
24 | return new DocumentModel(
25 | data.id,
26 | data.name,
27 | data.mod_time,
28 | data.file_size,
29 | );
30 | }
31 |
32 | private static toResourceModel(data: any): ResourceModel {
33 | return new ResourceModel(
34 | data.id,
35 | data.name,
36 | data.mod_time,
37 | data.file_size,
38 | );
39 | }
40 |
41 | private axiosClient: AxiosInstance;
42 |
43 | public constructor(host: string, authEnabled: boolean, user: string, password: string) {
44 | if (!host) {
45 | host = 'localhost';
46 | }
47 |
48 | const config = {
49 | baseUrl: host,
50 | timeout: 1000,
51 | baseURL: host,
52 | auth: {
53 | username: user,
54 | password,
55 | },
56 | };
57 |
58 | if (!authEnabled || !user || !password) {
59 | // @ts-ignore
60 | delete config.auth;
61 | }
62 |
63 | this.axiosClient = axios.create(config);
64 | }
65 |
66 | public getTree(): Promise
10 |
3 |
15 |
16 |
17 |
109 |
110 |
126 |
--------------------------------------------------------------------------------
/src/components/Settings.vue:
--------------------------------------------------------------------------------
1 |
2 | {{ fileName }}
4 | 5 |
3 |
4 | Server
5 |
6 |
7 |
8 |
9 |
11 |
12 |
13 |
14 |
15 | Authentication
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
28 |
29 |
30 |
31 |
32 |
33 |
35 |
36 |
37 |
38 |
39 | Editor
40 |
41 |
42 |
43 |
44 |
45 | Editor & Preview
46 | Only Preview
47 | Only Editor
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
120 |
121 |
132 |
--------------------------------------------------------------------------------
/src/components/about/About.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
7 |
8 |
10 |
11 |
12 |
13 |
14 |
32 |
33 |
35 |
--------------------------------------------------------------------------------
/src/components/about/pages/AboutApp.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
9 |
10 |
35 |
36 |
37 |
50 |
51 |
58 |
--------------------------------------------------------------------------------
/src/components/about/pages/libraries/AboutLibraries.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 | 
6 |
7 | {{ $appName }}
8 |
9 |
10 |
6 | 11 | MkDocsEditor is a Markdown editor for MkDocs projects. 12 |
13 |14 | It communicates with the mkdocsrest 15 | backend and allows easy 16 | editing of Markdown files. 17 |
18 | 19 |More Info
20 | 21 |
22 |
23 | 
24 |
25 |
26 | Markus Ressel
27 |
28 |
30 | link
31 |
32 |
33 |
34 |
24 | {{ library.name }}
6 | {{ library.license}}
7 |
16 | Author:
17 | {{ library.author}}
18 |
19 |
20 |
21 | Description:
22 | {{ library.description}}
23 |
24 |
3 |
6 | add
7 | edit
8 |
9 |
10 |
11 |
12 |
61 |
62 |
65 |
--------------------------------------------------------------------------------
/src/components/browser/section/DocumentListItem.vue:
--------------------------------------------------------------------------------
1 |
2 | File Browser
4 |
3 |
4 |
5 |
13 |
14 |
15 |
16 |
17 | edit
18 |
19 |
20 |
21 | delete
22 |
23 |
24 |
25 |
26 |
35 |
36 |
37 |
76 |
77 |
89 |
--------------------------------------------------------------------------------
/src/components/browser/section/ResourceListItem.vue:
--------------------------------------------------------------------------------
1 |
2 |
6 | description
7 | {{ document.name }}
8 |
9 |
10 | {{ document.file_size}}
11 |
12 |
3 |
4 |
5 | attach_file
6 | {{ resource.name }}
7 |
8 | edit
9 |
10 |
11 | delete
12 |
13 |
14 |
15 |
16 |
32 |
33 |
34 |
81 |
82 |
89 |
--------------------------------------------------------------------------------
/src/components/browser/section/SectionListItem.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | folder
6 | {{ section.name }}
7 |
8 | edit
9 |
10 |
11 | delete
12 |
13 |
14 |
15 |
16 |
33 |
34 |
35 |
96 |
97 |
104 |
--------------------------------------------------------------------------------
/src/components/browser/section/SectionOverview.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
6 |
12 |
13 |
19 |
20 |
26 |
27 |
28 |
29 |
30 |
79 |
80 |
87 |
--------------------------------------------------------------------------------
/src/libraries/PowerArray.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | var mainContainer, module = module || undefined, isModule = false, isBrowser = true;
3 | if (typeof module !== "undefined") {
4 | module.exports = {};
5 | isModule = true;
6 | }
7 |
8 | if (typeof window === 'object') {
9 | mainContainer = window;
10 | } else {
11 | isBrowser = false;
12 | mainContainer = global;
13 | }
14 | if (mainContainer.pa && console && console.warn) {
15 | console.warn('PowerArray => Cannot load, global variable "pa" already exists. Assuming that pa is already loaded => Trusting older instance');
16 | }
17 | mainContainer.PowerArray = mainContainer.pa = function (object) {
18 | if (object.constructor === Array || object.paIsArray) {
19 | return new paArray(object);
20 | } else {
21 | //console.warn('PowerArray => The passed object is not natively an array. Trying to handle it as an array-like object...')
22 | if ((mainContainer.ol !== undefined && ol.Collection) && object instanceof ol.Collection) {
23 | // console.log('Compatible openlayers object detected (ol.Collection)');
24 | return paArray(object.getArray());
25 | }
26 | if (object.length === undefined) {
27 | throw new Error('PowerArray => The passed object is not an array, or usable as such.');
28 | }
29 | return new paArray(object);
30 | }
31 | };
32 | pa.mainContainer = mainContainer; //pa.mainContainer is a reference to the top element containing the application (window by browsers, global by Node);
33 |
34 | /*functions directly bound to the pa object: */
35 | mainContainer.pa.Range = function (from, to, step) {
36 | if (!pa.IsNumeric(from)) {
37 | throw new Error('PowerArray => Range fuction => The parameter "from" must be numeric. Wrong value is "' + from + '"');
38 | }
39 | if (!pa.IsNumeric(to)) {
40 | throw new Error('PowerArray => Range fuction => The parameter "to" must be numeric. Received value is "' + to + '"');
41 | }
42 | if (!pa.IsNumeric(step)) {
43 | throw new Error('PowerArray => Range fuction => The parameter "step" must be numeric. Received value is "' + step + '"');
44 | }
45 |
46 | from = parseFloat(from);
47 | to = parseFloat(to);
48 | step = parseFloat(step);
49 |
50 | var result = [], i, l, currVal = from;
51 | while (currVal < to) {
52 | result.push(currVal);
53 | currVal += step;
54 | }
55 | result.push(to);
56 | return result;
57 | };
58 | mainContainer.pa.config = {
59 | defaults: {
60 | defaultPromiseTimeout: 10000
61 | }
62 | };
63 | mainContainer.pa.utils = {}
64 | mainContainer.pa.utils = {
65 | DataTypes: {
66 | String: 'String',
67 | Number: 'Number',
68 | Date: 'Date',
69 | Boolean: 'Boolean',
70 | Object: 'Object',
71 | ArrayOfObjects: 'ArrayOfObjects',
72 | ArrayOfPrimitives: 'ArrayOfPrimitives',
73 | RegExp: 'RegExp',
74 | Function: 'Function',
75 | Null: 'Null',
76 | Undefined: 'Undefined'
77 | },
78 | IsStringDate: function (str) {
79 | return (str.length === 20 && str.substr(19, 1) === 'Z' && str.substr(10, 1) === 'T');
80 | },
81 | IsArrayOfObjects: function (val) {
82 | var l;
83 | if (!val.paIsArray || val.length === undefined) {
84 | return false;
85 | }
86 | l = val.length;
87 | while (l--) {
88 | //TODO: this could fail in collections having objects but one undefined
89 | if (pa.utils.GetTypeOf(val[l]) !== pa.utils.DataTypes.Object) {
90 | return false;
91 | }
92 | }
93 | return true;
94 | },
95 | /**
96 | * Parses a string to boolean value. This function searches strictly for the strings "true", "True", "trUE", "falsE", etc.
97 | * @param str the string to be evaluated
98 | * @param throwIfNotMatch Boolean, if true, an exception will be raised if the string does not match. If false, null will be returned
99 | * @returns {*} boolean value if string matches, null if not
100 | */
101 | parseBoolean: function (str, throwIfNotMatch) {
102 | if (!pa.utils.isNullEmptyOrUndefined(str)) {
103 | var strU = str.toUpperCase();
104 | if (strU === "TRUE") {
105 | return true;
106 | }
107 | if (strU === "FALSE") {
108 | return false;
109 | }
110 | }
111 |
112 | if (throwIfNotMatch) {
113 | throw new Error("The string passed to function parseBoolean (" + str + ") doesn't match with any valid string");
114 | }
115 |
116 | return null;
117 | }, /**
118 | * evaluate if something is empty. Deppending on the passed object what it exactly search for:
119 | * Numbers and Strings are evaluated against "", undefined and Null
120 | * Objects having at least one own property returns false (also if the property is empty!)
121 | * Arrays returns false if his length is > 0
122 | *
123 | * @param what the element to evaluate
124 | * @returns {boolean}
125 | */
126 | isNullEmptyOrUndefined: function (what) {
127 | // null has to be evaluated before checking typeof
128 |
129 | if (what === null || what === undefined) {
130 | return true;
131 | }
132 | var t = typeof what;
133 | if (t === "boolean") {
134 | return false;
135 | }
136 |
137 | //Array
138 | if (what.paIsArray && what.length > 0)
139 | return false;
140 |
141 | //Object
142 | if (t === 'object') {
143 | var count = 0;
144 | for (var p in what) {
145 | if (what.hasOwnProperty(p))
146 | return false;
147 | }
148 | return true;
149 | }
150 |
151 | if (t !== "number" && t !== "string" && t !== "undefined") {
152 | throw new Error("PowerArray => The function IsNullOrEmpty is designed to evaluate strings and numbers, but something different was provided (" + t + ")");
153 | }
154 |
155 | if (t === "number" && what === 0) {
156 | return false;
157 | }
158 |
159 | if (!what) {
160 | return true;
161 | }
162 | return (what + "").length === 0;
163 | },
164 | /**
165 | * Copy properties from a source object to a destination object
166 | * @param {Object} source source object
167 | * @param {Object} dest destination object
168 | * @param {Array